@fluidframework/odsp-driver 0.59.4001 → 1.1.0-75972

package/src/epochTracker.ts

@@ -55,6 +55,7 @@ export class EpochTracker implements IPersistedFileCache {
         protected readonly cache: IPersistedCache,
         protected readonly fileEntry: IFileEntry,
         protected readonly logger: ITelemetryLogger,
+        protected readonly clientIsSummarizer?: boolean,
     ) {
         // Limits the max number of concurrent requests to 24.
         this.rateLimiter = new RateLimiter(24);
@@ -300,7 +301,12 @@ export class EpochTracker implements IPersistedFileCache {
     }
 
     private formatClientCorrelationId(fetchReason?: string) {
-        const items: string[] = [`driverId=${this.driverId}`, `RequestNumber=${this.networkCallNumber++}`];
+        const items: string[] = [
+            `driverId=${this.driverId}`,
+            `RequestNumber=${this.networkCallNumber++}`,
+            `driverVersion=${driverVersion}`,
+            `isSummarizer=${this.clientIsSummarizer}`,
+        ];
         if (fetchReason !== undefined) {
             items.push(`fetchReason=${fetchReason}`);
         }
@@ -475,8 +481,9 @@ export function createOdspCacheAndTracker(
     persistedCacheArg: IPersistedCache,
     nonpersistentCache: INonPersistentCache,
     fileEntry: IFileEntry,
-    logger: ITelemetryLogger): ICacheAndTracker {
-    const epochTracker = new EpochTrackerWithRedemption(persistedCacheArg, fileEntry, logger);
+    logger: ITelemetryLogger,
+    clientIsSummarizer?: boolean): ICacheAndTracker {
+    const epochTracker = new EpochTrackerWithRedemption(persistedCacheArg, fileEntry, logger, clientIsSummarizer);
     return {
         cache: {
             ...nonpersistentCache,

package/src/fetchSnapshot.ts

@@ -8,7 +8,7 @@ import { v4 as uuid } from "uuid";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { assert, fromUtf8ToBase64, performance } from "@fluidframework/common-utils";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { isFluidError, PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
 import {
     IOdspResolvedUrl,
     ISnapshotOptions,
@@ -16,7 +16,7 @@ import {
     InstrumentedStorageTokenFetcher,
 } from "@fluidframework/odsp-driver-definitions";
 import { ISnapshotTree } from "@fluidframework/protocol-definitions";
-import { isRuntimeMessage } from "@fluidframework/driver-utils";
+import { isRuntimeMessage, NonRetryableError } from "@fluidframework/driver-utils";
 import { IOdspSnapshot, ISnapshotCachedEntry, IVersionedValueWithEpoch, persistedCacheValueVersion } from "./contracts";
 import { getQueryString } from "./getQueryString";
 import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
@@ -26,12 +26,13 @@ import {
     getWithRetryForTokenRefresh,
     getWithRetryForTokenRefreshRepeat,
     IOdspResponse,
-    ISnapshotContents,
 } from "./odspUtils";
-import { convertOdspSnapshotToSnapsohtTreeAndBlobs } from "./odspSnapshotParser";
+import { ISnapshotContents } from "./odspPublicUtils";
+import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "./odspSnapshotParser";
 import { currentReadVersion, parseCompactSnapshotResponse } from "./compactSnapshotParser";
 import { ReadBuffer } from "./ReadBufferUtils";
 import { EpochTracker } from "./epochTracker";
+import { pkgVersion } from "./packageVersion";
 
 /**
  * Enum to support different types of snapshot formats.
@@ -83,7 +84,7 @@ export async function fetchSnapshot(
         },
         async () => snapshotDownloader(url, { headers }),
     ) as IOdspResponse<IOdspSnapshot>;
-    return convertOdspSnapshotToSnapsohtTreeAndBlobs(response.content);
+    return convertOdspSnapshotToSnapshotTreeAndBlobs(response.content);
 }
 
 export async function fetchSnapshotWithRedeem(
@@ -93,11 +94,11 @@ export async function fetchSnapshotWithRedeem(
     forceAccessTokenViaAuthorizationHeader: boolean,
     logger: ITelemetryLogger,
     snapshotDownloader: (
-            finalOdspResolvedUrl: IOdspResolvedUrl,
-            storageToken: string,
-            snapshotOptions: ISnapshotOptions | undefined,
-            controller?: AbortController,
-        ) => Promise<ISnapshotRequestAndResponseOptions>,
+        finalOdspResolvedUrl: IOdspResolvedUrl,
+        storageToken: string,
+        snapshotOptions: ISnapshotOptions | undefined,
+        controller?: AbortController,
+    ) => Promise<ISnapshotRequestAndResponseOptions>,
     putInCache: (valueWithEpoch: IVersionedValueWithEpoch) => Promise<void>,
     removeEntries: () => Promise<void>,
     enableRedeemFallback?: boolean,
@@ -126,12 +127,13 @@ export async function fetchSnapshotWithRedeem(
             await redeemSharingLink(
                 odspResolvedUrl, storageTokenFetcher, logger, forceAccessTokenViaAuthorizationHeader);
             const odspResolvedUrlWithoutShareLink: IOdspResolvedUrl =
-                { ...odspResolvedUrl,
-                    shareLinkInfo: {
-                        ...odspResolvedUrl.shareLinkInfo,
-                        sharingLinkToRedeem: undefined,
-                    },
-                };
+            {
+                ...odspResolvedUrl,
+                shareLinkInfo: {
+                    ...odspResolvedUrl.shareLinkInfo,
+                    sharingLinkToRedeem: undefined,
+                },
+            };
 
             return fetchLatestSnapshotCore(
                 odspResolvedUrlWithoutShareLink,
@@ -168,15 +170,15 @@ async function redeemSharingLink(
             eventName: "RedeemShareLink",
         },
         async () => getWithRetryForTokenRefresh(async (tokenFetchOptions) => {
-                assert(!!odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem,
-                    0x1ed /* "Share link should be present" */);
-                const storageToken = await storageTokenFetcher(tokenFetchOptions, "RedeemShareLink");
-                const encodedShareUrl = getEncodedShareUrl(odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem);
-                const redeemUrl = `${odspResolvedUrl.siteUrl}/_api/v2.0/shares/${encodedShareUrl}`;
-                const { url, headers } = getUrlAndHeadersWithAuth(
-                    redeemUrl, storageToken, forceAccessTokenViaAuthorizationHeader);
-                headers.prefer = "redeemSharingLink";
-                return fetchAndParseAsJSONHelper(url, { headers });
+            assert(!!odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem,
+                0x1ed /* "Share link should be present" */);
+            const storageToken = await storageTokenFetcher(tokenFetchOptions, "RedeemShareLink");
+            const encodedShareUrl = getEncodedShareUrl(odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem);
+            const redeemUrl = `${odspResolvedUrl.siteUrl}/_api/v2.0/shares/${encodedShareUrl}`;
+            const { url, headers } = getUrlAndHeadersWithAuth(
+                redeemUrl, storageToken, forceAccessTokenViaAuthorizationHeader);
+            headers.prefer = "redeemSharingLink";
+            return fetchAndParseAsJSONHelper(url, { headers });
         }),
     );
 }
@@ -187,11 +189,11 @@ async function fetchLatestSnapshotCore(
     snapshotOptions: ISnapshotOptions | undefined,
     logger: ITelemetryLogger,
     snapshotDownloader: (
-            finalOdspResolvedUrl: IOdspResolvedUrl,
-            storageToken: string,
-            snapshotOptions: ISnapshotOptions | undefined,
-            controller?: AbortController,
-        ) => Promise<ISnapshotRequestAndResponseOptions>,
+        finalOdspResolvedUrl: IOdspResolvedUrl,
+        storageToken: string,
+        snapshotOptions: ISnapshotOptions | undefined,
+        controller?: AbortController,
+    ) => Promise<ISnapshotRequestAndResponseOptions>,
     putInCache: (valueWithEpoch: IVersionedValueWithEpoch) => Promise<void>,
     enableRedeemFallback?: boolean,
 ): Promise<ISnapshotContents> {
@@ -232,7 +234,64 @@ async function fetchLatestSnapshotCore(
                     snapshotOptions,
                     controller,
                 );
-                const snapshot = response.odspSnapshotResponse.content;
+                const odspResponse = response.odspResponse;
+                const contentType = odspResponse.headers.get("content-type");
+                odspResponse.propsToLog = {
+                    ...odspResponse.propsToLog,
+                    contentType,
+                    accept: response.requestHeaders.accept,
+                };
+                let parsedSnapshotContents: IOdspResponse<ISnapshotContents> | undefined;
+                try {
+                    switch (contentType) {
+                        case "application/json": {
+                            const text = await odspResponse.content.text();
+                            odspResponse.propsToLog.bodySize = text.length;
+                            const content: IOdspSnapshot = JSON.parse(text);
+                            validateBlobsAndTrees(content);
+                            const snapshotContents: ISnapshotContents =
+                                convertOdspSnapshotToSnapshotTreeAndBlobs(content);
+                            parsedSnapshotContents = { ...odspResponse, content: snapshotContents };
+                            break;
+                        }
+                        case "application/ms-fluid": {
+                            const content = await odspResponse.content.arrayBuffer();
+                            odspResponse.propsToLog.bodySize = content.byteLength;
+                            const snapshotContents: ISnapshotContents = parseCompactSnapshotResponse(
+                                new ReadBuffer(new Uint8Array(content)));
+                            if (snapshotContents.snapshotTree.trees === undefined ||
+                                snapshotContents.snapshotTree.blobs === undefined) {
+                                    throw new NonRetryableError(
+                                        "Returned odsp snapshot is malformed. No trees or blobs!",
+                                        DriverErrorType.incorrectServerResponse,
+                                        { driverVersion: pkgVersion, ...odspResponse.propsToLog },
+                                    );
+                                }
+                            parsedSnapshotContents = { ...odspResponse, content: snapshotContents };
+                            break;
+                        }
+                        default:
+                            throw new NonRetryableError(
+                                "Unknown snapshot content type",
+                                DriverErrorType.incorrectServerResponse,
+                                { driverVersion: pkgVersion, ...odspResponse.propsToLog },
+                            );
+                    }
+                } catch (error) {
+                    if (isFluidError(error)) {
+                        error.addTelemetryProperties({ driverVersion: pkgVersion, ...odspResponse.propsToLog });
+                        throw error;
+                    }
+                    const enhancedError = wrapError(
+                        error,
+                        (errorMessage) => new NonRetryableError(
+                            `Error parsing snapshot response: ${errorMessage}`,
+                            DriverErrorType.genericError,
+                            { driverVersion: pkgVersion, ...odspResponse.propsToLog }));
+                    throw enhancedError;
+                }
+                assert(parsedSnapshotContents !== undefined, 0x312 /* snapshot should be parsed */);
+                const snapshot = parsedSnapshotContents.content;
                 // From: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming
                 // fetchStart: immediately before the browser starts to fetch the resource.
                 // requestStart: immediately before the browser starts requesting the resource from the server
@@ -254,7 +313,7 @@ async function fetchLatestSnapshotCore(
                 let fetchStartToResponseEndTime: number | undefined; // responseEnd  - fetchStart
                 let reqStartToResponseEndTime: number | undefined; // responseEnd - requestStart
                 let networkTime: number | undefined; // responseEnd - startTime
-                const spReqDuration = response.odspSnapshotResponse.headers.get("sprequestduration");
+                const spReqDuration = odspResponse.headers.get("sprequestduration");
 
                 // getEntriesByType is only available in browser performance object
                 const resources1 = performance.getEntriesByType?.("resource") ?? [];
@@ -286,12 +345,12 @@ async function fetchLatestSnapshotCore(
                 }
 
                 const { numTrees, numBlobs, encodedBlobsSize } =
-                    validateAndEvalBlobsAndTrees(response.odspSnapshotResponse.content);
+                    evalBlobsAndTrees(parsedSnapshotContents.content);
 
                 // There are some scenarios in ODSP where we cannot cache, trees/latest will explicitly tell us when we
                 // cannot cache using an HTTP response header.
                 const canCache =
-                    response.odspSnapshotResponse.headers.get("disablebrowsercachingofusercontent") !== "true";
+                    odspResponse.headers.get("disablebrowsercachingofusercontent") !== "true";
                 const sequenceNumber: number = snapshot.sequenceNumber ?? 0;
                 const seqNumberFromOps = snapshot.ops && snapshot.ops.length > 0 ?
                     snapshot.ops[0].sequenceNumber - 1 :
@@ -302,7 +361,7 @@ async function fetchLatestSnapshotCore(
                     logger.sendErrorEvent({ eventName: "fetchSnapshotError", sequenceNumber, seqNumberFromOps });
                     snapshot.sequenceNumber = undefined;
                 } else if (canCache) {
-                    const fluidEpoch = response.odspSnapshotResponse.headers.get("x-fluid-epoch");
+                    const fluidEpoch = odspResponse.headers.get("x-fluid-epoch");
                     assert(fluidEpoch !== undefined, 0x1e6 /* "Epoch  should be present in response" */);
                     const value: ISnapshotCachedEntry = {
                         ...snapshot,
@@ -346,8 +405,8 @@ async function fetchLatestSnapshotCore(
                     // Azure Fluid Relay service; desc=S, FRP; desc=False. Here, FRL is the duration taken for redeem,
                     // Azure Fluid Relay service is the redeem status (S means success), and FRP is a flag to indicate
                     // if the permission has changed.
-                    sltelemetry: response.odspSnapshotResponse.headers.get("x-fluid-sltelemetry"),
-                    ...response.odspSnapshotResponse.propsToLog,
+                    sltelemetry: odspResponse.headers.get("x-fluid-sltelemetry"),
+                    ...odspResponse.propsToLog,
                 });
                 return snapshot;
             },
@@ -363,8 +422,8 @@ async function fetchLatestSnapshotCore(
     });
 }
 
-interface ISnapshotRequestAndResponseOptions {
-    odspSnapshotResponse: IOdspResponse<ISnapshotContents>;
+export interface ISnapshotRequestAndResponseOptions {
+    odspResponse: IOdspResponse<Response>;
     requestUrl: string;
     requestHeaders: { [index: string]: any; };
 }
@@ -406,11 +465,7 @@ function getFormBodyAndHeaders(
     return { body: postBody, headers: header };
 }
 
-function validateAndEvalBlobsAndTrees(snapshot: ISnapshotContents) {
-    assert(snapshot.snapshotTree !== undefined,
-        0x200 /* "Returned odsp snapshot is malformed. No trees!" */);
-    assert(snapshot.blobs !== undefined,
-        0x201 /* "Returned odsp snapshot is malformed. No blobs!" */);
+function evalBlobsAndTrees(snapshot: ISnapshotContents) {
     const numTrees = countTreesInSnapshotTree(snapshot.snapshotTree);
     const numBlobs = snapshot.blobs.size;
     let encodedBlobsSize = 0;
@@ -420,6 +475,13 @@ function validateAndEvalBlobsAndTrees(snapshot: ISnapshotContents) {
     return { numTrees, numBlobs, encodedBlobsSize };
 }
 
+export function validateBlobsAndTrees(snapshot: IOdspSnapshot) {
+    assert(snapshot.trees !== undefined,
+        0x200 /* "Returned odsp snapshot is malformed. No trees!" */);
+    assert(snapshot.blobs !== undefined,
+        0x201 /* "Returned odsp snapshot is malformed. No blobs!" */);
+}
+
 function countTreesInSnapshotTree(snapshotTree: ISnapshotTree): number {
     let numTrees = 0;
     for (const [_, tree] of Object.entries(snapshotTree.trees)) {
@@ -448,6 +510,7 @@ export async function downloadSnapshot(
     snapshotFormatFetchType?: SnapshotFormatSupportType,
     controller?: AbortController,
     epochTracker?: EpochTracker,
+    scenarioName?: string,
 ): Promise<ISnapshotRequestAndResponseOptions> {
     // back-compat: This block to be removed with #8784 when we only consume/consider odsp resolvers that are >= 0.51
     const sharingLinkToRedeem = (odspResolvedUrl as any).sharingLinkToRedeem;
@@ -482,28 +545,11 @@ export async function downloadSnapshot(
             headers.accept = "application/json";
     }
 
-    const response = await (epochTracker?.fetch(url, fetchOptions, "treesLatest", true) ??
+    const odspResponse = await (epochTracker?.fetch(url, fetchOptions, "treesLatest", true, scenarioName) ??
         fetchHelper(url, fetchOptions));
 
-    let finalSnapshotContents: IOdspResponse<ISnapshotContents>;
-    const contentType = response.headers.get("content-type");
-    if (contentType === "application/json") {
-        const text = await response.content.text();
-        const content: IOdspSnapshot = JSON.parse(text);
-        response.propsToLog.bodySize = text.length;
-        const snapshotContents: ISnapshotContents = convertOdspSnapshotToSnapsohtTreeAndBlobs(content);
-        finalSnapshotContents = { ...response, content: snapshotContents };
-    } else {
-        assert(contentType === "application/ms-fluid", 0x2c3 /* "Content type should be application/ms-fluid" */);
-        const content = await response.content.arrayBuffer();
-        response.propsToLog.bodySize = content.byteLength;
-        const snapshotContents: ISnapshotContents = parseCompactSnapshotResponse(
-            new ReadBuffer(new Uint8Array(content)));
-        finalSnapshotContents = { ...response, content: snapshotContents };
-    }
-    response.propsToLog.contentType = contentType;
     return {
-        odspSnapshotResponse: finalSnapshotContents,
+        odspResponse,
         requestHeaders: headers,
         requestUrl: url,
     };
@@ -513,7 +559,7 @@ function isRedeemSharingLinkError(odspResolvedUrl: IOdspResolvedUrl, error: any)
     if (odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem !== undefined
         && (typeof error === "object" && error !== null)
         && (error.errorType === DriverErrorType.authorizationError
-        || error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError)) {
+            || error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError)) {
         return true;
     }
     return false;
@@ -526,9 +572,9 @@ function getEncodedShareUrl(url: string): string {
      */
     let encodedUrl = fromUtf8ToBase64(encodeURI(url));
     encodedUrl = encodedUrl
-      .replace(/=+$/g, "")
-      .replace(/\//g, "_")
-      .replace(/\+/g, "-");
+        .replace(/=+$/g, "")
+        .replace(/\//g, "_")
+        .replace(/\+/g, "-");
     encodedUrl = "u!".concat(encodedUrl);
     return encodedUrl;
 }

package/src/index.ts

@@ -31,3 +31,7 @@ export * from "./odspDriverUrlResolver";
 
 // It's used by URL resolve code, but also has some public functions
 export * from "./odspFluidFileLink";
+
+// Wire format related
+export * from "./compactSnapshotParser";
+export * from "./ReadBufferUtils";

package/src/odspDocumentDeltaConnection.ts

@@ -128,7 +128,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
             this.isPendingInitialConnection = false;
 
             // Explicitly cast error to the specified event args type to ensure type compatibility
-            this.emit("server_disconnect", error as IFluidErrorBase & OdspError);
+            this.emit("server_disconnect", error);
             this.closeSocket();
         });
     }
@@ -440,7 +440,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
     }
 
     protected serverDisconnectHandler = (error: IFluidErrorBase & OdspError) => {
-        this.logger.sendTelemetryEvent({ eventName: "ServerDisconnect" }, error);
+        this.logger.sendTelemetryEvent({ eventName: "ServerDisconnect", clientId: this.clientId }, error);
         this.disposeCore(true, error);
     };
 
@@ -460,7 +460,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
             };
         }
 
-        this.socketReference!.once("server_disconnect", this.serverDisconnectHandler);
+        this.socketReference!.on("server_disconnect", this.serverDisconnectHandler);
 
         this.socket.on("get_ops_response", (result: IGetOpsResponse) => {
             const messages = result.messages;
@@ -553,20 +553,20 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
             case "nack":
                 // per client / document nack handling
                 super.addTrackedListener(event, (clientIdOrDocumentId: string, nacks: INack[]) => {
-                    if (clientIdOrDocumentId.length === 0 ||
+                    const handle = clientIdOrDocumentId.length === 0 ||
                         clientIdOrDocumentId === this.documentId ||
-                        (this.hasDetails && clientIdOrDocumentId === this.clientId)) {
-                        const nackContent = nacks[0]?.content;
-                        if (nackContent !== undefined) {
-                            const { code, type, message, retryAfter } = nackContent;
-                            this.logger.sendTelemetryEvent({
-                                eventName: "ServerNack",
-                                code,
-                                type,
-                                message,
-                                retryAfterSeconds: retryAfter,
-                            });
-                        }
+                        (clientIdOrDocumentId === this.clientId);
+                    const { code, type, message, retryAfter } = nacks[0]?.content ?? {};
+                    this.logger.sendTelemetryEvent({
+                        eventName: "ServerNack",
+                        code,
+                        type,
+                        message,
+                        retryAfterSeconds: retryAfter,
+                        clientId: this.clientId,
+                        handle,
+                    });
+                    if (handle) {
                         this.emit("nack", clientIdOrDocumentId, nacks);
                     }
                 });
@@ -584,9 +584,9 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
     protected disconnect(socketProtocolError: boolean, reason: IAnyDriverError) {
         const socket = this.socketReference;
         assert(socket !== undefined, 0x0a2 /* "reentrancy not supported!" */);
-        this.socketReference = undefined;
 
-        this.socket.off("server_disconnect", this.serverDisconnectHandler);
+        this.socketReference?.off("server_disconnect", this.serverDisconnectHandler);
+        this.socketReference = undefined;
 
         if (!socketProtocolError && this.hasDetails) {
             // tell the server we are disconnecting this client from the document

package/src/odspDocumentService.ts

@@ -21,7 +21,7 @@ import {
     IDocumentServicePolicies,
     DriverErrorType,
 } from "@fluidframework/driver-definitions";
-import { DeltaStreamConnectionForbiddenError, NonRetryableError } from "@fluidframework/driver-utils";
+import { canRetryOnError, DeltaStreamConnectionForbiddenError, NonRetryableError } from "@fluidframework/driver-utils";
 import { IFacetCodes } from "@fluidframework/odsp-doclib-utils";
 import {
     IClient,
@@ -415,12 +415,16 @@ export class OdspDocumentService implements IDocumentService {
             if (response.refreshAfterDeltaMs > 0) {
                 this.scheduleJoinSessionRefresh(response.refreshAfterDeltaMs)
                     .catch((error) => {
-                        this.mc.logger.sendErrorEvent({
+                        const canRetry = canRetryOnError(error);
+                        // Only record error event in case it is non retriable.
+                        if (!canRetry) {
+                            this.mc.logger.sendErrorEvent({
                                 eventName: "JoinSessionRefreshError",
                                 details: JSON.stringify(props),
                             },
                             error,
-                        );
+                            );
+                        }
                     });
             } else {
                 // Logging just for informational purposes to help with debugging as this is a new feature.

package/src/odspDocumentServiceFactoryCore.ts

@@ -102,7 +102,8 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
             this.persistedCache,
             this.nonPersistentCache,
             fileEntry,
-            odspLogger);
+            odspLogger,
+            clientIsSummarizer);
 
         return PerformanceEvent.timedExecAsync(
             odspLogger,
@@ -189,7 +190,8 @@ export class OdspDocumentServiceFactoryCore implements IDocumentServiceFactory {
             this.persistedCache,
             this.nonPersistentCache,
             { resolvedUrl: odspResolvedUrl, docId: odspResolvedUrl.hashedDocumentId },
-            odspLogger);
+            odspLogger,
+            clientIsSummarizer);
 
         const storageTokenFetcher = toInstrumentedOdspTokenFetcher(
             odspLogger,

package/src/odspDocumentStorageManager.ts

@@ -38,8 +38,8 @@ import { IOdspCache } from "./odspCache";
 import {
     createCacheSnapshotKey,
     getWithRetryForTokenRefresh,
-    ISnapshotContents,
 } from "./odspUtils";
+import { ISnapshotContents } from "./odspPublicUtils";
 import { defaultCacheExpiryTimeoutMs, EpochTracker } from "./epochTracker";
 import { OdspSummaryUploadManager } from "./odspSummaryUploadManager";
 import { FlushResult } from "./odspDocumentDeltaConnection";
@@ -275,7 +275,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                                 method: "POST",
                             },
                             "createBlob",
-                    ));
+                        ));
                     event.end({
                         blobId: res.content.id,
                         ...res.propsToLog,
@@ -343,14 +343,14 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         return this.readBlobCore(blobId);
     }
 
-    public async getSnapshotTree(version?: api.IVersion): Promise<api.ISnapshotTree | null> {
+    public async getSnapshotTree(version?: api.IVersion, scenarioName?: string): Promise<api.ISnapshotTree | null> {
         if (!this.snapshotUrl) {
             return null;
         }
 
         let id: string;
         if (!version || !version.id) {
-            const versions = await this.getVersions(null, 1);
+            const versions = await this.getVersions(null, 1, scenarioName);
             if (!versions || versions.length === 0) {
                 return null;
             }
@@ -359,7 +359,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
             id = version.id;
         }
 
-        const snapshotTree = await this.readTree(id);
+        const snapshotTree = await this.readTree(id, scenarioName);
         if (!snapshotTree) {
             return null;
         }
@@ -379,7 +379,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         return this.combineProtocolAndAppSnapshotTree(appTree, protocolTree);
     }
 
-    public async getVersions(blobid: string | null, count: number): Promise<api.IVersion[]> {
+    public async getVersions(blobid: string | null, count: number, scenarioName?: string): Promise<api.IVersion[]> {
         // Regular load workflow uses blobId === documentID to indicate "latest".
         if (blobid !== this.documentId && blobid) {
             // FluidFetch & FluidDebugger tools use empty sting to query for versions
@@ -437,14 +437,14 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                                 }
 
                                 return snapshotCachedEntry;
-                        });
+                            });
 
                     // Based on the concurrentSnapshotFetch policy:
                     // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
                     // or grab the cache value and then the network value if the cache value returns undefined.
                     let method: string;
                     if (this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
-                        const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions);
+                        const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions, scenarioName);
 
                         // Ensure that failures on both paths are ignored initially.
                         // I.e. if cache fails for some reason, we will proceed with network result.
@@ -478,7 +478,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         method = retrievedSnapshot !== undefined ? "cache" : "network";
 
                         if (retrievedSnapshot === undefined) {
-                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions);
+                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
                         }
                     }
                     if (method === "network") {
@@ -524,7 +524,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                     eventName: "getVersions",
                     headers: Object.keys(headers).length !== 0 ? true : undefined,
                 },
-                async () => this.epochTracker.fetchAndParseAsJSON<IDocumentStorageGetVersionsResponse>(url, { headers }, "versions"),
+                async () => this.epochTracker.fetchAndParseAsJSON<IDocumentStorageGetVersionsResponse>(url, { headers }, "versions", undefined, scenarioName),
             );
             const versionsResponse = response.content;
             if (!versionsResponse) {
@@ -548,8 +548,8 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         });
     }
 
-    private async fetchSnapshot(hostSnapshotOptions: ISnapshotOptions | undefined) {
-        return this.fetchSnapshotCore(hostSnapshotOptions).catch((error) => {
+    private async fetchSnapshot(hostSnapshotOptions: ISnapshotOptions | undefined, scenarioName?: string) {
+        return this.fetchSnapshotCore(hostSnapshotOptions, scenarioName).catch((error) => {
             // Issue #5895:
             // If we are offline, this error is retryable. But that means that RetriableDocumentStorageService
             // will run in circles calling getSnapshotTree, which would result in OdspDocumentStorageService class
@@ -562,7 +562,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         });
     }
 
-    private async fetchSnapshotCore(hostSnapshotOptions: ISnapshotOptions | undefined) {
+    private async fetchSnapshotCore(hostSnapshotOptions: ISnapshotOptions | undefined, scenarioName?: string) {
         const snapshotOptions: ISnapshotOptions = {
             mds: this.maxSnapshotSizeLimit,
             ...hostSnapshotOptions,
@@ -589,6 +589,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                 this.snapshotFormatFetchType,
                 controller,
                 this.epochTracker,
+                scenarioName,
             );
         };
         const putInCache = async (valueWithEpoch: IVersionedValueWithEpoch) => {
@@ -642,19 +643,13 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         }
     }
 
-    public async write(tree: api.ITree, parents: string[], message: string): Promise<api.IVersion> {
-        this.checkSnapshotUrl();
-
-        throw new Error("Not supported");
-    }
-
     public async uploadSummaryWithContext(summary: api.ISummaryTree, context: ISummaryContext): Promise<string> {
         this.checkSnapshotUrl();
 
         // Enable flushing only if we have single commit summary and this is not the initial summary for an empty file
         if (".protocol" in summary.tree && context.ackHandle !== undefined) {
             let retry = 0;
-            for (;;) {
+            for (; ;) {
                 const result = await this.flushCallback();
                 const seq = result.lastPersistedSequenceNumber;
                 if (seq !== undefined && seq >= context.referenceSequenceNumber) {
@@ -726,7 +721,7 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
         }
     }
 
-    private async readTree(id: string): Promise<api.ISnapshotTree | null> {
+    private async readTree(id: string, scenarioName?: string): Promise<api.ISnapshotTree | null> {
         if (!this.snapshotUrl) {
             return null;
         }
@@ -739,6 +734,8 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         url,
                         fetchOptions,
                         "snapshotTree",
+                        undefined,
+                        scenarioName,
                     );
                 };
                 const snapshot = await fetchSnapshot(