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

package/src/opLifecycle/opDecompressor.ts

@@ -6,6 +6,8 @@
 import { decompress } from "lz4js";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { assert, IsoBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
+import { ChildLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { CompressionAlgorithms } from "../containerRuntime";
 import { IMessageProcessingResult } from "./definitions";
 
@@ -21,13 +23,18 @@ export class OpDecompressor {
     private activeBatch = false;
     private rootMessageContents: any | undefined;
     private processedCount = 0;
+    private readonly logger;
+
+    constructor(logger: ITelemetryLogger) {
+        this.logger = ChildLogger.create(logger, "OpDecompressor");
+    }
 
     public processMessage(message: ISequencedDocumentMessage): IMessageProcessingResult {
         assert(
             message.compression === undefined || message.compression === CompressionAlgorithms.lz4,
             0x511 /* Only lz4 compression is supported */);
 
-        if (message.metadata?.batch === true && message.compression === CompressionAlgorithms.lz4) {
+        if (message.metadata?.batch === true && this.isCompressed(message)) {
             // Beginning of a compressed batch
             assert(this.activeBatch === false, 0x4b8 /* shouldn't have multiple active batches */);
             if (message.compression) {
@@ -74,7 +81,7 @@ export class OpDecompressor {
             };
         }
 
-        if (message.metadata?.batch === undefined && message.compression === CompressionAlgorithms.lz4) {
+        if (message.metadata?.batch === undefined && this.isCompressed(message)) {
             // Single compressed message
             assert(this.activeBatch === false, 0x4ba /* shouldn't receive compressed message in middle of a batch */);
 
@@ -94,6 +101,46 @@ export class OpDecompressor {
             state: "Skipped",
         };
     }
+
+    private isCompressed(message: ISequencedDocumentMessage) {
+        if (message.compression === CompressionAlgorithms.lz4) {
+            return true;
+        }
+
+        /**
+         * Back-compat self healing mechanism for ADO:3538, as loaders from
+         * version client_v2.0.0-internal.1.2.0 to client_v2.0.0-internal.2.2.0 do not
+         * support adding the proper compression metadata to compressed messages submitted
+         * by the runtime. Should be removed after the loader reaches sufficient saturation
+         * for a version greater or equal than client_v2.0.0-internal.2.2.0.
+         *
+         * The condition holds true for compressed messages, regardless of metadata. We are ultimately
+         * looking for a message with a single property `packedContents` inside `contents`, of type 'string'
+         * with a base64 encoded value.
+         */
+        try {
+            if (
+                typeof message.contents === "object" &&
+                Object.keys(message.contents).length === 1 &&
+                message.contents?.packedContents !== undefined &&
+                typeof message.contents?.packedContents === "string" &&
+                message.contents.packedContents.length > 0 &&
+                IsoBuffer.from(message.contents.packedContents, "base64").toString("base64") ===
+                message.contents.packedContents
+            ) {
+                this.logger.sendTelemetryEvent({
+                    eventName: "LegacyCompression",
+                    type: message.type,
+                    batch: message.metadata?.batch,
+                });
+                return true;
+            }
+        } catch (err) {
+            return false;
+        }
+
+        return false;
+    }
 }
 
 // We should not be mutating the input message nor its metadata

package/src/opLifecycle/outbox.ts

@@ -114,8 +114,9 @@ export class Outbox {
     private compressBatch(batch: IBatch): IBatch {
         if (batch.content.length === 0
             || this.params.config.compressionOptions === undefined
-            || this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes) {
-            // Nothing to do if the batch is empty or if compression is disabled or if we don't need to compress
+            || this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes
+            || this.params.containerContext.submitBatchFn === undefined) {
+            // Nothing to do if the batch is empty or if compression is disabled or not supported, or if we don't need to compress
             return batch;
         }
 

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.3";

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 =