@fluidframework/container-runtime 2.0.0-internal.3.0.1 → 2.0.0-internal.3.0.2

package/src/containerRuntime.ts

@@ -94,6 +94,7 @@ import {
     addSummarizeResultToSummary,
     addTreeToSummary,
     createRootSummarizerNodeWithGC,
+    IFetchSnapshotResult,
     IRootSummarizerNodeWithGC,
     RequestParser,
     create404Response,
@@ -103,6 +104,7 @@ import {
     seqFromTree,
     calculateStats,
     TelemetryContext,
+    ReadAndParseBlob,
 } from "@fluidframework/runtime-utils";
 import { GCDataBuilder, trimLeadingAndTrailingSlashes } from "@fluidframework/garbage-collector";
 import { v4 as uuid } from "uuid";
@@ -2175,12 +2177,21 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             fullGC,
         } = options;
 
+        const telemetryContext = new TelemetryContext();
+        // Add the options that are used to generate this summary to the telemetry context.
+        telemetryContext.setAll("fluid_Summarize", "Options", {
+            fullTree,
+            trackState,
+            runGC,
+            fullGC,
+            runSweep,
+        });
+
         let gcStats: IGCStats | undefined;
         if (runGC) {
-            gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC });
+            gcStats = await this.collectGarbage({ logger: summaryLogger, runSweep, fullGC }, telemetryContext);
         }
 
-        const telemetryContext = new TelemetryContext();
         const { stats, summary } = await this.summarizerNode.summarize(fullTree, trackState, telemetryContext);
 
         this.logger.sendTelemetryEvent({ eventName: "SummarizeTelemetry", details: telemetryContext.serialize() });
@@ -2334,8 +2345,9 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
             /** True to generate full GC data */
             fullGC?: boolean;
         },
+        telemetryContext?: ITelemetryContext,
     ): Promise<IGCStats | undefined> {
-        return this.garbageCollector.collectGarbage(options);
+        return this.garbageCollector.collectGarbage(options, telemetryContext);
     }
 
     /**
@@ -2835,18 +2847,17 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
         // The call to fetch the snapshot is very expensive and not always needed.
         // It should only be done by the summarizerNode, if required.
         // When fetching from storage we will always get the latest version and do not use the ackHandle.
-        const snapshotTreeFetcher = async () => {
+        const fetchLatestSnapshot: () => Promise<IFetchSnapshotResult> = async () => {
             const fetchResult = await this.fetchLatestSnapshotFromStorage(
                 summaryLogger,
                 {
-                    eventName: "RefreshLatestSummaryGetSnapshot",
+                    eventName: "RefreshLatestSummaryAckFetch",
                     ackHandle,
-                    summaryRefSeq,
-                    fetchLatest: true,
+                    targetSequenceNumber: summaryRefSeq,
                 },
+                readAndParseBlob,
             );
 
-            const latestSnapshotRefSeq = await seqFromTree(fetchResult.snapshotTree, readAndParseBlob);
             /**
              * If the fetched snapshot is older than the one for which the ack was received, close the container.
              * This should never happen because an ack should be sent after the latest summary is updated in the server.
@@ -2857,7 +2868,7 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
              * such cases, the file will be rolled back along with the ack and we will eventually reach a consistent
              * state.
              */
-            if (latestSnapshotRefSeq < summaryRefSeq) {
+            if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
                 const error = DataProcessingError.create(
                     "Fetched snapshot is older than the received ack",
                     "RefreshLatestSummaryAck",
@@ -2865,44 +2876,36 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
                     {
                         ackHandle,
                         summaryRefSeq,
-                        latestSnapshotRefSeq,
+                        latestSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
                     },
                 );
                 this.closeFn(error);
                 throw error;
             }
 
-            summaryLogger.sendTelemetryEvent(
-                {
-                    eventName: "LatestSummaryRetrieved",
-                    ackHandle,
-                    lastSequenceNumber: latestSnapshotRefSeq,
-                    targetSequenceNumber: summaryRefSeq,
-                });
-
             // In case we had to retrieve the latest snapshot and it is different than summaryRefSeq,
             // wait for the delta manager to catch up before refreshing the latest Summary.
-            await this.waitForDeltaManagerToCatchup(latestSnapshotRefSeq,
-                summaryLogger);
+            await this.waitForDeltaManagerToCatchup(
+                fetchResult.latestSnapshotRefSeq,
+                summaryLogger,
+            );
 
-            return fetchResult.snapshotTree;
+            return {
+                snapshotTree: fetchResult.snapshotTree,
+                snapshotRefSeq: fetchResult.latestSnapshotRefSeq,
+            };
         };
 
         const result = await this.summarizerNode.refreshLatestSummary(
             proposalHandle,
             summaryRefSeq,
-            snapshotTreeFetcher,
+            fetchLatestSnapshot,
             readAndParseBlob,
             summaryLogger,
         );
 
         // Notify the garbage collector so it can update its latest summary state.
-        await this.garbageCollector.refreshLatestSummary(
-            result,
-            proposalHandle,
-            summaryRefSeq,
-            readAndParseBlob,
-        );
+        await this.garbageCollector.refreshLatestSummary(proposalHandle, result, readAndParseBlob);
     }
 
     /**
@@ -2914,30 +2917,31 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     private async refreshLatestSummaryAckFromServer(
         summaryLogger: ITelemetryLogger,
     ): Promise<{ latestSnapshotRefSeq: number; latestSnapshotVersionId: string | undefined; }> {
-        const { snapshotTree, versionId } = await this.fetchLatestSnapshotFromStorage(
-            summaryLogger,
-            {
-                eventName: "RefreshLatestSummaryGetSnapshot",
-                fetchLatest: true,
-            },
-        );
-
         const readAndParseBlob = async <T>(id: string) => readAndParse<T>(this.storage, id);
-        const latestSnapshotRefSeq = await seqFromTree(snapshotTree, readAndParseBlob);
-
+        const { snapshotTree, versionId, latestSnapshotRefSeq } =
+            await this.fetchLatestSnapshotFromStorage(
+                summaryLogger,
+                {
+                    eventName: "RefreshLatestSummaryFromServerFetch",
+                },
+                readAndParseBlob,
+            );
+        const fetchLatestSnapshot: IFetchSnapshotResult = {
+            snapshotTree,
+            snapshotRefSeq: latestSnapshotRefSeq,
+        };
         const result = await this.summarizerNode.refreshLatestSummary(
-            undefined,
+            undefined /* proposalHandle */,
             latestSnapshotRefSeq,
-            async () => snapshotTree,
+            async () => fetchLatestSnapshot,
             readAndParseBlob,
             summaryLogger,
         );
 
         // Notify the garbage collector so it can update its latest summary state.
         await this.garbageCollector.refreshLatestSummary(
+            undefined /* proposalHandle */,
             result,
-            undefined,
-            latestSnapshotRefSeq,
             readAndParseBlob,
         )
 
@@ -2947,29 +2951,54 @@ export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents>
     private async fetchLatestSnapshotFromStorage(
         logger: ITelemetryLogger,
         event: ITelemetryGenericEvent,
-    ): Promise<{ snapshotTree: ISnapshotTree; versionId: string; }> {
+        readAndParseBlob: ReadAndParseBlob,
+    ): Promise<{ snapshotTree: ISnapshotTree; versionId: string; latestSnapshotRefSeq: number }> {
         return PerformanceEvent.timedExecAsync(
-            logger, event, async (perfEvent: {
+            logger,
+            event,
+            async (perfEvent: {
                 end: (arg0: {
                     getVersionDuration?: number | undefined;
                     getSnapshotDuration?: number | undefined;
+                    snapshotRefSeq?: number | undefined;
+                    snapshotVersion?: string | undefined;
                 }) => void;
             }) => {
-            const stats: { getVersionDuration?: number; getSnapshotDuration?: number; } = {};
+            const stats: {
+                getVersionDuration?: number;
+                getSnapshotDuration?: number;
+                snapshotRefSeq?: number;
+                snapshotVersion?: string;
+            } = {};
             const trace = Trace.start();
 
             const versions = await this.storage.getVersions(
-                null, 1, "refreshLatestSummaryAckFromServer", FetchSource.noCache);
-            assert(!!versions && !!versions[0], 0x137 /* "Failed to get version from storage" */);
+                null,
+                1,
+                "refreshLatestSummaryAckFromServer",
+                FetchSource.noCache,
+            );
+            assert(
+                !!versions && !!versions[0],
+                0x137 /* "Failed to get version from storage" */,
+            );
             stats.getVersionDuration = trace.trace().duration;
 
             const maybeSnapshot = await this.storage.getSnapshotTree(versions[0]);
             assert(!!maybeSnapshot, 0x138 /* "Failed to get snapshot from storage" */);
             stats.getSnapshotDuration = trace.trace().duration;
+            const latestSnapshotRefSeq = await seqFromTree(maybeSnapshot, readAndParseBlob);
+            stats.snapshotRefSeq = latestSnapshotRefSeq;
+            stats.snapshotVersion = versions[0].id;
 
             perfEvent.end(stats);
-            return { snapshotTree: maybeSnapshot, versionId: versions[0].id };
-        });
+            return {
+                snapshotTree: maybeSnapshot,
+                versionId: versions[0].id,
+                latestSnapshotRefSeq,
+            };
+            },
+        );
     }
 
     public notifyAttaching(snapshot: ISnapshotTreeWithBlobContents) {

package/src/dataStoreContext.ts

@@ -61,9 +61,11 @@ import {
 import {
     addBlobToSummary,
     convertSummaryTreeToITree,
+    packagePathToTelemetryProperty,
 } from "@fluidframework/runtime-utils";
 import {
     ChildLogger,
+    generateStack,
     loggerToMonitoringContext,
     LoggingError,
     MonitoringContext,
@@ -261,6 +263,13 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
     private readonly thresholdOpsCounter: ThresholdCounter;
     private static readonly pendingOpsCountThreshold = 1000;
 
+    /**
+     * If the summarizer makes local changes, a telemetry event is logged. This has the potential to be very noisy.
+     * So, adding a count of how many telemetry events are logged per data store context. This can be
+     * controlled via feature flags.
+     */
+    private localChangesTelemetryCount: number;
+
     // The used routes of this node as per the last GC run. This is used to update the used routes of the channel
     // if it realizes after GC is run.
     private lastUsedRoutes: string[] | undefined;
@@ -318,6 +327,10 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         this.throwOnTombstoneUsage =
             this.mc.config.getBoolean(throwOnTombstoneUsageKey) === true &&
             this.clientDetails.type !== summarizerClientType;
+
+        // By default, a data store can log maximum 10 local changes telemetry in summarizer.
+        this.localChangesTelemetryCount =
+            this.mc.config.getNumber("Fluid.Telemetry.LocalChangesTelemetryCount") ?? 10;
     }
 
     public dispose(): void {
@@ -343,8 +356,15 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         this._tombstoned = tombstone;
     }
 
-    private rejectDeferredRealize(reason: string, packageName?: string): never {
-        throw new LoggingError(reason, { packageName: { value: packageName, tag: TelemetryDataTag.CodeArtifact } });
+    private rejectDeferredRealize(
+        reason: string,
+        failedPkgPath?: string,
+        fullPackageName?: readonly string[],
+    ): never {
+        throw new LoggingError(reason, {
+            failedPkgPath: { value: failedPkgPath, tag: TelemetryDataTag.CodeArtifact },
+            fullPackageName: packagePathToTelemetryProperty(fullPackageName),
+        });
     }
 
     public async realize(): Promise<IFluidDataStoreChannel> {
@@ -358,6 +378,7 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
                         value: this.id,
                         tag: TelemetryDataTag.CodeArtifact,
                     },
+                    packageName: packagePathToTelemetryProperty(this.pkg),
                 });
                 this.channelDeferred?.reject(errorWrapped);
                 this.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
@@ -377,18 +398,22 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         let lastPkg: string | undefined;
         for (const pkg of packages) {
             if (!registry) {
-                this.rejectDeferredRealize("No registry for package", lastPkg);
+                this.rejectDeferredRealize("No registry for package", lastPkg, packages);
             }
             lastPkg = pkg;
             entry = await registry.get(pkg);
             if (!entry) {
-                this.rejectDeferredRealize("Registry does not contain entry for the package", pkg);
+                this.rejectDeferredRealize(
+                    "Registry does not contain entry for the package",
+                    pkg,
+                    packages,
+                );
             }
             registry = entry.IFluidDataStoreRegistry;
         }
         const factory = entry?.IFluidDataStoreFactory;
         if (factory === undefined) {
-            this.rejectDeferredRealize("Can't find factory for package", lastPkg);
+            this.rejectDeferredRealize("Can't find factory for package", lastPkg, packages);
         }
 
         return { factory, registry };
@@ -627,6 +652,10 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
             content,
             type,
         };
+
+        // Summarizer clients should not submit messages.
+        this.identifyLocalChangeInSummarizer("DataStoreMessageSubmittedInSummarizer", type);
+
         this._containerRuntime.submitDataStoreOp(
             this.id,
             fluidDataStoreContent,
@@ -800,6 +829,33 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         }
     }
 
+    /**
+     * Summarizer client should not have local changes. These changes can become part of the summary and can break
+     * eventual consistency. For example, the next summary (say at ref seq# 100) may contain these changes whereas
+     * other clients that are up-to-date till seq# 100 may not have them yet.
+     */
+    protected identifyLocalChangeInSummarizer(eventName: string, type?: string) {
+        if (this.clientDetails.type !== summarizerClientType || this.localChangesTelemetryCount <= 0) {
+            return;
+        }
+
+        // Log a telemetry if there are local changes in the summarizer. This will give us data on how often
+        // this is happening and which data stores do this. The eventual goal is to disallow local changes
+        // in the summarizer and the data will help us plan this.
+        this.mc.logger.sendTelemetryEvent({
+            eventName,
+            type,
+            fluidDataStoreId: {
+                value: this.id,
+                tag: TelemetryDataTag.CodeArtifact,
+            },
+            packageName: packagePathToTelemetryProperty(this.pkg),
+            isSummaryInProgress: this.summarizerNode.isSummaryInProgress?.(),
+            stack: generateStack(),
+        });
+        this.localChangesTelemetryCount--;
+    }
+
     public getCreateChildSummarizerNodeFn(id: string, createParam: CreateChildSummarizerNodeParam) {
         return (
             summarizeInternal: SummarizeInternalFn,
@@ -922,6 +978,9 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
             props.makeLocallyVisibleFn,
         );
 
+        // Summarizer client should not create local data stores.
+        this.identifyLocalChangeInSummarizer("DataStoreCreatedInSummarizer");
+
         this.snapshotTree = props.snapshotTree;
         if (props.isRootDataStore === true) {
             this.setInMemoryRoot();

package/src/garbageCollection.ts

@@ -63,7 +63,8 @@ import {
     runSessionExpiryKey,
     runSweepKey,
     stableGCVersion,
-    trackGCStateKey
+    trackGCStateKey,
+    gcTombstoneGenerationOptionName
 } from "./garbageCollectionConstants";
 import { sendGCTombstoneEvent } from "./garbageCollectionTombstoneUtils";
 import { SweepReadyUsageDetectionHandler } from "./gcSweepReadyUsageDetection";
@@ -76,6 +77,7 @@ import {
     dataStoreAttributesBlobName,
     IGCMetadata,
     ICreateContainerMetadata,
+    GCFeatureMatrix,
 } from "./summaryFormat";
 
 /** The statistics of the system state after a garbage collection run. */
@@ -145,6 +147,7 @@ export interface IGarbageCollector {
     /** Run garbage collection and update the reference / used state of the system. */
     collectGarbage(
         options: { logger?: ITelemetryLogger; runSweep?: boolean; fullGC?: boolean; },
+        telemetryContext?: ITelemetryContext,
     ): Promise<IGCStats | undefined>;
     /** Summarizes the GC data and returns it as a summary tree. */
     summarize(
@@ -158,9 +161,8 @@ export interface IGarbageCollector {
     getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase>;
     /** Called when the latest summary of the system has been refreshed. */
     refreshLatestSummary(
-        result: RefreshSummaryResult,
         proposalHandle: string | undefined,
-        summaryRefSeq: number,
+        result: RefreshSummaryResult,
         readAndParseBlob: ReadAndParseBlob,
     ): Promise<void>;
     /** Called when a node is updated. Used to detect and log when an inactive node is changed or loaded. */
@@ -418,6 +420,9 @@ export class GarbageCollector implements IGarbageCollector {
     // This is the version of GC data in the latest summary being tracked.
     private latestSummaryGCVersion: GCVersion;
 
+	// Feature Support info persisted to this container's summary
+	private readonly persistedGcFeatureMatrix: GCFeatureMatrix | undefined;
+
     // Keeps track of the GC state from the last run.
     private gcDataFromLastRun: IGarbageCollectionData | undefined;
     // Keeps a list of references (edges in the GC graph) between GC runs. Each entry has a node id and a list of
@@ -557,6 +562,7 @@ export class GarbageCollector implements IGarbageCollector {
             this.sweepTimeoutMs =
                 metadata?.sweepTimeoutMs
                 ?? computeSweepTimeout(this.sessionExpiryTimeoutMs); // Backfill old documents that didn't persist this
+            this.persistedGcFeatureMatrix = metadata?.gcFeatureMatrix;
         } else {
             // Sweep should not be enabled without enabling GC mark phase. We could silently disable sweep in this
             // scenario but explicitly failing makes it clearer and promotes correct usage.
@@ -581,6 +587,11 @@ export class GarbageCollector implements IGarbageCollector {
             this.sweepTimeoutMs =
                 testOverrideSweepTimeoutMs
                 ?? computeSweepTimeout(this.sessionExpiryTimeoutMs);
+            if (this.gcOptions[gcTombstoneGenerationOptionName] !== undefined) {
+                this.persistedGcFeatureMatrix = {
+                    tombstoneGeneration: this.gcOptions[gcTombstoneGenerationOptionName],
+                };
+            }
         }
 
         // If session expiry is enabled, we need to close the container when the session expiry timeout expires.
@@ -950,6 +961,7 @@ export class GarbageCollector implements IGarbageCollector {
             /** True to generate full GC data */
             fullGC?: boolean;
         },
+        telemetryContext?: ITelemetryContext,
     ): Promise<IGCStats | undefined> {
         const fullGC = options.fullGC ?? (this.gcOptions.runFullGC === true || this.summaryStateNeedsReset);
         const logger = options.logger
@@ -974,6 +986,9 @@ export class GarbageCollector implements IGarbageCollector {
             return undefined;
         }
 
+        // Add the options that are used to run GC to the telemetry context.
+        telemetryContext?.setAll("fluid_GC", "Options", { fullGC, runSweep: options.runSweep });
+
         return PerformanceEvent.timedExecAsync(logger, { eventName: "GarbageCollection" }, async (event) => {
             await this.runPreGCSteps();
 
@@ -1160,6 +1175,7 @@ export class GarbageCollector implements IGarbageCollector {
              * into the metadata blob. If GC is disabled, the gcFeature is 0.
              */
             gcFeature: this.gcEnabled ? this.currentGCVersion : 0,
+            gcFeatureMatrix: this.persistedGcFeatureMatrix,
             sessionExpiryTimeoutMs: this.sessionExpiryTimeoutMs,
             sweepEnabled: this.sweepEnabled,
             sweepTimeoutMs: this.sweepTimeoutMs,
@@ -1179,9 +1195,8 @@ export class GarbageCollector implements IGarbageCollector {
      * is downloaded and should be used to update the state.
      */
     public async refreshLatestSummary(
-        result: RefreshSummaryResult,
         proposalHandle: string | undefined,
-        summaryRefSeq: number,
+        result: RefreshSummaryResult,
         readAndParseBlob: ReadAndParseBlob,
     ): Promise<void> {
         // If the latest summary was updated and the summary was tracked, this client is the one that generated this
@@ -1208,8 +1223,8 @@ export class GarbageCollector implements IGarbageCollector {
         }
 
         // If the summary was not tracked by this client, the state should be updated from the downloaded snapshot.
-        const snapshot = result.snapshot;
-        const metadataBlobId = snapshot.blobs[metadataBlobName];
+        const snapshotTree = result.snapshotTree;
+        const metadataBlobId = snapshotTree.blobs[metadataBlobName];
         if (metadataBlobId) {
             const metadata = await readAndParseBlob<IContainerRuntimeMetadata>(metadataBlobId);
             this.latestSummaryGCVersion = getGCVersion(metadata);
@@ -1223,10 +1238,10 @@ export class GarbageCollector implements IGarbageCollector {
                 "No reference timestamp when updating GC state from snapshot",
                 "refreshLatestSummary",
                 undefined,
-                { proposalHandle, summaryRefSeq, details: JSON.stringify(this.configs) },
+                { proposalHandle, summaryRefSeq: result.summaryRefSeq, details: JSON.stringify(this.configs) },
             );
         }
-        const gcSnapshotTree = snapshot.trees[gcTreeKey];
+        const gcSnapshotTree = snapshotTree.trees[gcTreeKey];
         // If GC ran in the container that generated this snapshot, it will have a GC tree.
         this.wasGCRunInLatestSummary = gcSnapshotTree !== undefined;
         let latestGCData: IGarbageCollectionSnapshotData | undefined;

package/src/garbageCollectionConstants.ts

@@ -10,6 +10,9 @@ export const stableGCVersion: GCVersion = 1;
 /** The current version of garbage collection. */
 export const currentGCVersion: GCVersion = 2;
 
+/** This undocumented GC Option (on ContainerRuntime Options) allows an app to disable enforcing GC on old documents by incrementing this value */
+export const gcTombstoneGenerationOptionName = "gcTombstoneGeneration";
+
 // Feature gate key to turn GC on / off.
 export const runGCKey = "Fluid.GarbageCollection.RunGC";
 // Feature gate key to turn GC sweep on / off.

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-internal.3.0.1";
+export const pkgVersion = "2.0.0-internal.3.0.2";

package/src/summaryFormat.ts

@@ -89,15 +89,37 @@ export interface ICreateContainerMetadata {
     createContainerTimestamp?: number;
 }
 
+/** @see IGCMetadata.gcFeatureMatrix */
+export interface GCFeatureMatrix {
+    /**
+     * The Tombstone Generation value in effect when this file was created.
+     * Gives a way for an app to disqualify old files from GC Tombstone enforcement
+     * Provided via Container Runtime Options
+     */
+    tombstoneGeneration?: number;
+}
+
 export type GCVersion = number;
 export interface IGCMetadata {
     /**
      * The version of the GC code that was run to generate the GC data that is written in the summary.
+     * If the persisted value doesn't match the current value in the code, saved GC data will be discarded and regenerated from scratch.
      * Also, used to determine whether GC is enabled for this container or not:
      * - A value of 0 or undefined means GC is disabled.
      * - A value greater than 0 means GC is enabled.
      */
     readonly gcFeature?: GCVersion;
+
+    /**
+     * Numerical indication of feature support as of file creation time, used to determine feature availability over time.
+     * This info may come from multiple sources (FF code, config service, app via Container Runtime Options),
+     * and pertains to aspects of the document that may be fixed for its lifetime.
+     *
+     * For each dimension, if the persisted value is less than the currently provided value,
+     * then this file does not support the corresponding feature as currently implemented.
+     */
+    readonly gcFeatureMatrix?: GCFeatureMatrix;
+
     /**
      * Tells whether the GC sweep phase is enabled for this container.
      * - True means sweep phase is enabled.

package/src/summaryGenerator.ts

@@ -205,11 +205,15 @@ export class SummaryGenerator {
             timeSinceLastSummary,
         };
 
-        const summarizeEvent = PerformanceEvent.start(logger, {
-            eventName: "Summarize",
-            refreshLatestAck,
-            ...summarizeTelemetryProps,
-        });
+        const summarizeEvent = PerformanceEvent.start(
+            logger,
+            {
+                eventName: "Summarize",
+                refreshLatestAck,
+                ...summarizeTelemetryProps,
+            },
+            { start: true, end: true, cancel: "generic" },
+        );
 
         // Helper functions to report failures and return.
         const getFailMessage =