@fluidframework/odsp-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/lib/{fetchSnapshot.js → fetchSnapshot.mjs}

@@ -2,23 +2,25 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { default as AbortController } from "abort-controller";
 import { v4 as uuid } from "uuid";
-import { assert, fromUtf8ToBase64, performance } from "@fluidframework/common-utils";
+import { isFluidError, PerformanceEvent, wrapError, } from "@fluidframework/telemetry-utils";
+import { fromUtf8ToBase64 } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
+import { getW3CData } from "@fluidframework/driver-base";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
-import { isFluidError, PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
 import { OdspErrorType, } from "@fluidframework/odsp-driver-definitions";
-import { isRuntimeMessage, NonRetryableError } from "@fluidframework/driver-utils";
-import { persistedCacheValueVersion } from "./contracts";
-import { getQueryString } from "./getQueryString";
-import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth";
-import { fetchAndParseAsJSONHelper, fetchHelper, getWithRetryForTokenRefresh, getWithRetryForTokenRefreshRepeat, } from "./odspUtils";
-import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "./odspSnapshotParser";
-import { currentReadVersion, parseCompactSnapshotResponse } from "./compactSnapshotParser";
-import { ReadBuffer } from "./ReadBufferUtils";
-import { pkgVersion } from "./packageVersion";
+import { isRuntimeMessage, NonRetryableError, } from "@fluidframework/driver-utils";
+import { fetchIncorrectResponse, throwOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { persistedCacheValueVersion, } from "./contracts.mjs";
+import { getQueryString } from "./getQueryString.mjs";
+import { getUrlAndHeadersWithAuth } from "./getUrlAndHeadersWithAuth.mjs";
+import { fetchAndParseAsJSONHelper, fetchHelper, getWithRetryForTokenRefresh, getWithRetryForTokenRefreshRepeat, measure, measureP, } from "./odspUtils.mjs";
+import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "./odspSnapshotParser.mjs";
+import { currentReadVersion, parseCompactSnapshotResponse, } from "./compactSnapshotParser.mjs";
+import { pkgVersion } from "./packageVersion.mjs";
 /**
  * Enum to support different types of snapshot formats.
+ * @alpha
  */
 export var SnapshotFormatSupportType;
 (function (SnapshotFormatSupportType) {
@@ -36,51 +38,62 @@ export var SnapshotFormatSupportType;
  * @param forceAccessTokenViaAuthorizationHeader - whether to force passing given token via authorization header
  * @returns A promise of the snapshot and the status code of the response
  */
-export async function fetchSnapshot(snapshotUrl, token, versionId, fetchFullSnapshot, forceAccessTokenViaAuthorizationHeader, logger, snapshotDownloader) {
+export async function fetchSnapshot(snapshotUrl, 
+// eslint-disable-next-line @rushstack/no-new-null
+token, versionId, fetchFullSnapshot, forceAccessTokenViaAuthorizationHeader, logger, snapshotDownloader) {
     const path = `/trees/${versionId}`;
     let queryParams = {};
     if (fetchFullSnapshot) {
-        if (versionId !== "latest") {
-            queryParams = { channels: 1, blobs: 2 };
-        }
-        else {
-            queryParams = { deltas: 1, channels: 1, blobs: 2 };
-        }
+        queryParams = versionId !== "latest" ? { blobs: 2 } : { deltas: 1, blobs: 2 };
     }
     const queryString = getQueryString(queryParams);
     const { url, headers } = getUrlAndHeadersWithAuth(`${snapshotUrl}${path}${queryString}`, token, forceAccessTokenViaAuthorizationHeader);
-    const response = await PerformanceEvent.timedExecAsync(logger, {
+    const response = (await PerformanceEvent.timedExecAsync(logger, {
         eventName: "fetchSnapshot",
         headers: Object.keys(headers).length !== 0 ? true : undefined,
-    }, async () => snapshotDownloader(url, { headers }));
+    }, async () => snapshotDownloader(url, { headers })));
     return convertOdspSnapshotToSnapshotTreeAndBlobs(response.content);
 }
 export async function fetchSnapshotWithRedeem(odspResolvedUrl, storageTokenFetcher, snapshotOptions, forceAccessTokenViaAuthorizationHeader, logger, snapshotDownloader, putInCache, removeEntries, enableRedeemFallback) {
     // back-compat: This block to be removed with #8784 when we only consume/consider odsp resolvers that are >= 0.51
     const sharingLinkToRedeem = odspResolvedUrl.sharingLinkToRedeem;
     if (sharingLinkToRedeem) {
-        odspResolvedUrl.shareLinkInfo = Object.assign(Object.assign({}, odspResolvedUrl.shareLinkInfo), { sharingLinkToRedeem });
+        odspResolvedUrl.shareLinkInfo = { ...odspResolvedUrl.shareLinkInfo, sharingLinkToRedeem };
     }
-    return fetchLatestSnapshotCore(odspResolvedUrl, storageTokenFetcher, snapshotOptions, logger, snapshotDownloader, putInCache, enableRedeemFallback).catch(async (error) => {
+    return fetchLatestSnapshotCore(odspResolvedUrl, storageTokenFetcher, snapshotOptions, logger, snapshotDownloader, putInCache, enableRedeemFallback)
+        .catch(async (error) => {
         if (enableRedeemFallback && isRedeemSharingLinkError(odspResolvedUrl, error)) {
             // Execute the redeem fallback
-            logger.sendErrorEvent({
+            await redeemSharingLink(odspResolvedUrl, storageTokenFetcher, logger, forceAccessTokenViaAuthorizationHeader);
+            const odspResolvedUrlWithoutShareLink = {
+                ...odspResolvedUrl,
+                shareLinkInfo: {
+                    ...odspResolvedUrl.shareLinkInfo,
+                    sharingLinkToRedeem: undefined,
+                },
+            };
+            // Log initial failure only if redeem succeeded - it points out to some bug somewhere
+            // If redeem failed, that most likely means user has no permissions to access a file,
+            // and thus it's not worth it logging extra errors - same error will be logged by end-to-end
+            // flow (container open) based on a failure above.
+            logger.sendTelemetryEvent({
                 eventName: "RedeemFallback",
                 errorType: error.errorType,
             }, error);
-            await redeemSharingLink(odspResolvedUrl, storageTokenFetcher, logger, forceAccessTokenViaAuthorizationHeader);
-            const odspResolvedUrlWithoutShareLink = Object.assign(Object.assign({}, odspResolvedUrl), { shareLinkInfo: Object.assign(Object.assign({}, odspResolvedUrl.shareLinkInfo), { sharingLinkToRedeem: undefined }) });
             return fetchLatestSnapshotCore(odspResolvedUrlWithoutShareLink, storageTokenFetcher, snapshotOptions, logger, snapshotDownloader, putInCache);
         }
         else {
             throw error;
         }
-    }).catch(async (error) => {
+    })
+        .catch(async (error) => {
         // Clear the cache on 401/403/404 on snapshot fetch from network because this means either the user doesn't
         // have permissions for the file or it was deleted. So, if we do not clear cache, we will continue fetching
         // snapshot from cache in the future.
-        if (typeof error === "object" && error !== null && error.errorType === DriverErrorType.authorizationError
-            || error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError) {
+        if ((typeof error === "object" &&
+            error !== null &&
+            error.errorType === DriverErrorType.authorizationError) ||
+            error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError) {
             await removeEntries();
         }
         throw error;
@@ -90,10 +103,9 @@ async function redeemSharingLink(odspResolvedUrl, storageTokenFetcher, logger, f
     return PerformanceEvent.timedExecAsync(logger, {
         eventName: "RedeemShareLink",
     }, async () => getWithRetryForTokenRefresh(async (tokenFetchOptions) => {
-        var _a, _b;
-        assert(!!((_a = odspResolvedUrl.shareLinkInfo) === null || _a === void 0 ? void 0 : _a.sharingLinkToRedeem), 0x1ed /* "Share link should be present" */);
+        assert(!!odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem, 0x1ed /* "Share link should be present" */);
         const storageToken = await storageTokenFetcher(tokenFetchOptions, "RedeemShareLink");
-        const encodedShareUrl = getEncodedShareUrl((_b = odspResolvedUrl.shareLinkInfo) === null || _b === void 0 ? void 0 : _b.sharingLinkToRedeem);
+        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";
@@ -102,18 +114,12 @@ async function redeemSharingLink(odspResolvedUrl, storageTokenFetcher, logger, f
 }
 async function fetchLatestSnapshotCore(odspResolvedUrl, storageTokenFetcher, snapshotOptions, logger, snapshotDownloader, putInCache, enableRedeemFallback) {
     return getWithRetryForTokenRefresh(async (tokenFetchOptions) => {
-        var _a;
         const storageToken = await storageTokenFetcher(tokenFetchOptions, "TreesLatest", true);
         assert(storageToken !== null, 0x1e5 /* "Storage token should not be null" */);
-        let controller;
-        if ((snapshotOptions === null || snapshotOptions === void 0 ? void 0 : snapshotOptions.timeout) !== undefined) {
-            controller = new AbortController();
-            setTimeout(() => controller.abort(), snapshotOptions.timeout);
-        }
         const perfEvent = {
             eventName: "TreesLatest",
             attempts: tokenFetchOptions.refresh ? 2 : 1,
-            shareLinkPresent: ((_a = odspResolvedUrl.shareLinkInfo) === null || _a === void 0 ? void 0 : _a.sharingLinkToRedeem) !== undefined,
+            shareLinkPresent: odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem !== undefined,
             isSummarizer: odspResolvedUrl.summarizer,
             redeemFallbackEnabled: enableRedeemFallback,
         };
@@ -126,38 +132,87 @@ async function fetchLatestSnapshotCore(odspResolvedUrl, storageTokenFetcher, sna
         }
         // This event measures only successful cases of getLatest call (no tokens, no retries).
         return PerformanceEvent.timedExecAsync(logger, perfEvent, async (event) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-            const response = await snapshotDownloader(odspResolvedUrl, storageToken, snapshotOptions, controller);
+            let controller;
+            let fetchTimeout;
+            if (snapshotOptions?.timeout !== undefined) {
+                controller = new AbortController();
+                fetchTimeout = setTimeout(() => controller.abort(), snapshotOptions.timeout);
+            }
+            const [response, fetchTime] = await measureP(async () => snapshotDownloader(odspResolvedUrl, storageToken, snapshotOptions, controller)).finally(() => {
+                // Clear the fetchTimeout once the response is fetched.
+                if (fetchTimeout !== undefined) {
+                    clearTimeout(fetchTimeout);
+                    fetchTimeout = undefined;
+                }
+            });
             const odspResponse = response.odspResponse;
             const contentType = odspResponse.headers.get("content-type");
-            // Measure how much time we spend processing payload
-            const snapshotParseEvent = PerformanceEvent.start(logger, {
-                eventName: "SnapshotParse",
-                driverVersion: pkgVersion,
+            const propsToLog = {
+                ...odspResponse.propsToLog,
                 contentType,
-            });
-            const propsToLog = Object.assign(Object.assign({}, odspResponse.propsToLog), { contentType, accept: response.requestHeaders.accept, driverVersion: pkgVersion });
+                accept: response.requestHeaders.accept,
+                driverVersion: pkgVersion,
+            };
             let parsedSnapshotContents;
+            let contentTypeToRead;
+            if (contentType?.includes("application/ms-fluid")) {
+                contentTypeToRead = "application/ms-fluid";
+            }
+            else if (contentType?.includes("application/json")) {
+                contentTypeToRead = "application/json";
+            }
+            let parseTime;
+            let receiveContentTime;
             try {
-                switch (contentType) {
+                switch (contentTypeToRead) {
                     case "application/json": {
-                        const text = await odspResponse.content.text();
+                        let text;
+                        [text, receiveContentTime] = await measureP(async () => odspResponse.content.text().catch((err) => 
+                        // Parsing can fail and message could contain full request URI, including
+                        // tokens, etc. So do not log error object itself.
+                        throwOdspNetworkError("Error while parsing fetch response", fetchIncorrectResponse, odspResponse.content, // response
+                        undefined, // response text
+                        propsToLog)));
                         propsToLog.bodySize = text.length;
-                        const content = JSON.parse(text);
+                        let content;
+                        [content, parseTime] = measure(() => JSON.parse(text));
                         validateBlobsAndTrees(content);
                         const snapshotContents = convertOdspSnapshotToSnapshotTreeAndBlobs(content);
-                        parsedSnapshotContents = Object.assign(Object.assign({}, odspResponse), { content: snapshotContents });
+                        parsedSnapshotContents = {
+                            ...odspResponse,
+                            content: {
+                                ...snapshotContents,
+                                telemetryProps: {},
+                            },
+                        };
                         break;
                     }
                     case "application/ms-fluid": {
-                        const content = await odspResponse.content.arrayBuffer();
+                        let content;
+                        [content, receiveContentTime] = await measureP(async () => odspResponse.content.arrayBuffer().catch((err) => 
+                        // Parsing can fail and message could contain full request URI, including
+                        // tokens, etc. So do not log error object itself.
+                        throwOdspNetworkError("Error while parsing fetch response", fetchIncorrectResponse, odspResponse.content, // response
+                        undefined, // response text
+                        propsToLog)));
                         propsToLog.bodySize = content.byteLength;
-                        const snapshotContents = parseCompactSnapshotResponse(new ReadBuffer(new Uint8Array(content)));
+                        let snapshotContents;
+                        [snapshotContents, parseTime] = measure(() => parseCompactSnapshotResponse(new Uint8Array(content), logger));
                         if (snapshotContents.snapshotTree.trees === undefined ||
                             snapshotContents.snapshotTree.blobs === undefined) {
                             throw new NonRetryableError("Returned odsp snapshot is malformed. No trees or blobs!", DriverErrorType.incorrectServerResponse, propsToLog);
                         }
-                        parsedSnapshotContents = Object.assign(Object.assign({}, odspResponse), { content: snapshotContents });
+                        const props = snapshotContents.telemetryProps;
+                        const slowTreeParseCodePaths = props.slowTreeStructureCount ?? 0;
+                        const slowBlobParseCodePaths = props.slowBlobStructureCount ?? 0;
+                        if (slowTreeParseCodePaths > 10 || slowBlobParseCodePaths > 10) {
+                            logger.sendErrorEvent({
+                                eventName: "SlowSnapshotParseCodePaths",
+                                slowTreeStructureCount: slowTreeParseCodePaths,
+                                slowBlobStructureCount: slowBlobParseCodePaths,
+                            });
+                        }
+                        parsedSnapshotContents = { ...odspResponse, content: snapshotContents };
                         break;
                     }
                     default:
@@ -175,72 +230,29 @@ async function fetchLatestSnapshotCore(odspResolvedUrl, storageTokenFetcher, sna
             assert(parsedSnapshotContents !== undefined, 0x312 /* snapshot should be parsed */);
             const snapshot = parsedSnapshotContents.content;
             const { trees, numBlobs, encodedBlobsSize } = evalBlobsAndTrees(snapshot);
-            // 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
-            // responseStart: immediately after the browser receives the first byte of the response from the server.
-            // responseEnd: immediately after the browser receives the last byte of the resource
-            //              or immediately before the transport connection is closed, whichever comes first.
-            // secureConnectionStart: immediately before the browser starts the handshake process to secure the
-            //              current connection. If a secure connection is not used, this property returns zero.
-            // startTime: Time when the resource fetch started. This value is equivalent to fetchStart.
-            // domainLookupStart: immediately before the browser starts the domain name lookup for the resource.
-            // domainLookupEnd: immediately after the browser finishes the domain name lookup for the resource.
-            // redirectStart: start time of the fetch which that initiates the redirect.
-            // redirectEnd: immediately after receiving the last byte of the response of the last redirect.
-            let dnsLookupTime; // domainLookupEnd - domainLookupStart
-            let redirectTime; // redirectEnd - redirectStart
-            let tcpHandshakeTime; // connectEnd  - connectStart
-            let secureConnectionTime; // connectEnd  - secureConnectionStart
-            let responseNetworkTime; // responsEnd - responseStart
-            let fetchStartToResponseEndTime; // responseEnd  - fetchStart
-            let reqStartToResponseEndTime; // responseEnd - requestStart
-            let networkTime; // responseEnd - startTime
-            const spReqDuration = odspResponse.headers.get("sprequestduration");
-            // getEntriesByType is only available in browser performance object
-            const resources1 = (_b = (_a = performance.getEntriesByType) === null || _a === void 0 ? void 0 : _a.call(performance, "resource")) !== null && _b !== void 0 ? _b : [];
-            // Usually the latest fetch call is to the end of resources, so we start from the end.
-            for (let i = resources1.length - 1; i > 0; i--) {
-                const indResTime = resources1[i];
-                const resource_name = indResTime.name;
-                const resource_initiatortype = indResTime.initiatorType;
-                if ((resource_initiatortype.localeCompare("fetch") === 0)
-                    && (resource_name.localeCompare(response.requestUrl) === 0)) {
-                    redirectTime = indResTime.redirectEnd - indResTime.redirectStart;
-                    dnsLookupTime = indResTime.domainLookupEnd - indResTime.domainLookupStart;
-                    tcpHandshakeTime = indResTime.connectEnd - indResTime.connectStart;
-                    secureConnectionTime = (indResTime.secureConnectionStart > 0) ?
-                        (indResTime.connectEnd - indResTime.secureConnectionStart) : undefined;
-                    responseNetworkTime = (indResTime.responseStart > 0) ?
-                        (indResTime.responseEnd - indResTime.responseStart) : undefined;
-                    fetchStartToResponseEndTime = (indResTime.fetchStart > 0) ?
-                        (indResTime.responseEnd - indResTime.fetchStart) : undefined;
-                    reqStartToResponseEndTime = (indResTime.requestStart > 0) ?
-                        (indResTime.responseEnd - indResTime.requestStart) : undefined;
-                    networkTime = (indResTime.startTime > 0) ?
-                        (indResTime.responseEnd - indResTime.fetchStart) : undefined;
-                    if (spReqDuration !== undefined && networkTime !== undefined) {
-                        networkTime = networkTime - parseInt(spReqDuration, 10);
-                    }
-                    break;
-                }
-            }
             // 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 = odspResponse.headers.get("disablebrowsercachingofusercontent") !== "true";
-            const sequenceNumber = (_c = snapshot.sequenceNumber) !== null && _c !== void 0 ? _c : 0;
-            const seqNumberFromOps = snapshot.ops && snapshot.ops.length > 0 ?
-                snapshot.ops[0].sequenceNumber - 1 :
-                undefined;
-            if (!Number.isInteger(sequenceNumber)
-                || seqNumberFromOps !== undefined && seqNumberFromOps !== sequenceNumber) {
-                logger.sendErrorEvent({ eventName: "fetchSnapshotError", sequenceNumber, seqNumberFromOps });
+            const sequenceNumber = snapshot.sequenceNumber ?? 0;
+            const seqNumberFromOps = snapshot.ops && snapshot.ops.length > 0
+                ? snapshot.ops[0].sequenceNumber - 1
+                : undefined;
+            if (!Number.isInteger(sequenceNumber) ||
+                (seqNumberFromOps !== undefined && seqNumberFromOps !== sequenceNumber)) {
+                logger.sendErrorEvent({
+                    eventName: "fetchSnapshotError",
+                    sequenceNumber,
+                    seqNumberFromOps,
+                });
                 snapshot.sequenceNumber = undefined;
             }
             else if (canCache) {
                 const fluidEpoch = odspResponse.headers.get("x-fluid-epoch");
                 assert(fluidEpoch !== undefined, 0x1e6 /* "Epoch  should be present in response" */);
-                const value = Object.assign(Object.assign({}, snapshot), { cacheEntryTime: Date.now() });
+                const value = {
+                    ...snapshot,
+                    cacheEntryTime: Date.now(),
+                };
                 const valueWithEpoch = {
                     value,
                     fluidEpoch,
@@ -249,57 +261,59 @@ async function fetchLatestSnapshotCore(odspResolvedUrl, storageTokenFetcher, sna
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 putInCache(valueWithEpoch);
             }
-            snapshotParseEvent.end();
-            event.end(Object.assign({ trees, blobs: (_e = (_d = snapshot.blobs) === null || _d === void 0 ? void 0 : _d.size) !== null && _e !== void 0 ? _e : 0, leafNodes: numBlobs, encodedBlobsSize,
-                sequenceNumber, ops: (_g = (_f = snapshot.ops) === null || _f === void 0 ? void 0 : _f.length) !== null && _g !== void 0 ? _g : 0, userOps: (_j = (_h = snapshot.ops) === null || _h === void 0 ? void 0 : _h.filter((op) => isRuntimeMessage(op)).length) !== null && _j !== void 0 ? _j : 0, headers: Object.keys(response.requestHeaders).length !== 0 ? true : undefined, 
-                // Interval between the first fetch until the last byte of the last redirect.
-                redirectTime,
-                // Interval between start and finish of the domain name lookup for the resource.
-                dnsLookupTime,
-                // Interval to receive all (first to last) bytes form the server.
-                responseNetworkTime,
-                // Time to establish the connection to the server to retrieve the resource.
-                tcpHandshakeTime,
-                // Time from the end of the connection until the inital handshake process to secure the connection.
-                secureConnectionTime,
-                // Interval between the initial fetch until the last byte is received.
-                fetchStartToResponseEndTime,
-                // Interval between starting the request for the resource until receiving the last byte.
-                reqStartToResponseEndTime,
-                // Interval between starting the request for the resource until receiving the last byte but
-                // excluding the Snaphot request duration indicated on the snapshot response header.
-                networkTime, 
+            event.end({
+                trees,
+                blobs: snapshot.blobs?.size ?? 0,
+                leafNodes: numBlobs,
+                encodedBlobsSize,
+                sequenceNumber,
+                ops: snapshot.ops?.length ?? 0,
+                userOps: snapshot.ops?.filter((op) => isRuntimeMessage(op)).length ?? 0,
+                headers: Object.keys(response.requestHeaders).length !== 0 ? true : undefined,
+                // Measures time to make fetch call. Should be similar to
+                // fetchStartToResponseEndTime - receiveContentTime, i.e. it looks like it's time till first byte /
+                // end of response headers
+                fetchTime,
+                // time it takes client to parse payload. Same payload as in "SnapshotParse" event, here for
+                // easier analyzes.
+                parseTime,
+                // Time it takes to receive content (text of buffer) from Response object.
+                // This time likely is very closely correlated with networkTime, i.e. time it takes to receive
+                // actual content (starting measuring from first bite / end of response header)
+                receiveContentTime,
+                ...getW3CData(response.requestUrl, "fetch"),
                 // Sharing link telemetry regarding sharing link redeem status and performance. Ex: FRL; dur=100,
                 // 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: odspResponse.headers.get("x-fluid-sltelemetry") }, propsToLog));
+                sltelemetry: odspResponse.headers.get("x-fluid-sltelemetry"),
+                // All other props
+                ...propsToLog,
+                // Various perf counters and measures collected by binary parsing code:
+                // slowTreeStructureCount, slowBlobStructureCount, durationStructure, durationStrings,
+                // durationSnapshotTree, durationBlobs, etc.
+                ...parsedSnapshotContents.content.telemetryProps,
+            });
             return snapshot;
         }).catch((error) => {
             // We hit these errors in stress tests, under load
             // It's useful to try one more time in such case.
-            if (typeof error === "object" && error !== null && (error.errorType === DriverErrorType.fetchFailure ||
-                error.errorType === OdspErrorType.fetchTimeout)) {
+            if (typeof error === "object" &&
+                error !== null &&
+                (error.errorType === DriverErrorType.fetchFailure ||
+                    error.errorType === OdspErrorType.fetchTimeout)) {
                 error[getWithRetryForTokenRefreshRepeat] = true;
             }
             throw error;
         });
     });
 }
-function getFormBodyAndHeaders(odspResolvedUrl, storageToken, snapshotOptions, headers) {
-    var _a, _b;
+function getFormBodyAndHeaders(odspResolvedUrl, storageToken, headers) {
     const formBoundary = uuid();
     const formParams = [];
     formParams.push(`--${formBoundary}`);
     formParams.push(`Authorization: Bearer ${storageToken}`);
     formParams.push(`X-HTTP-Method-Override: GET`);
-    if (snapshotOptions !== undefined) {
-        Object.entries(snapshotOptions).forEach(([key, value]) => {
-            if (value !== undefined) {
-                formParams.push(`${key}: ${value}`);
-            }
-        });
-    }
     if (headers !== undefined) {
         Object.entries(headers).forEach(([key, value]) => {
             if (value !== undefined) {
@@ -307,8 +321,8 @@ function getFormBodyAndHeaders(odspResolvedUrl, storageToken, snapshotOptions, h
             }
         });
     }
-    if ((_a = odspResolvedUrl.shareLinkInfo) === null || _a === void 0 ? void 0 : _a.sharingLinkToRedeem) {
-        formParams.push(`sl: ${(_b = odspResolvedUrl.shareLinkInfo) === null || _b === void 0 ? void 0 : _b.sharingLinkToRedeem}`);
+    if (odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem) {
+        formParams.push(`sl: ${odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem}`);
     }
     formParams.push(`_post: 1`);
     formParams.push(`\r\n--${formBoundary}--`);
@@ -318,7 +332,7 @@ function getFormBodyAndHeaders(odspResolvedUrl, storageToken, snapshotOptions, h
     };
     return { body: postBody, headers: header };
 }
-function evalBlobsAndTrees(snapshot) {
+export function evalBlobsAndTrees(snapshot) {
     const trees = countTreesInSnapshotTree(snapshot.snapshotTree);
     const numBlobs = snapshot.blobs.size;
     let encodedBlobsSize = 0;
@@ -351,38 +365,45 @@ function countTreesInSnapshotTree(snapshotTree) {
  * @returns fetched snapshot.
  */
 export async function downloadSnapshot(odspResolvedUrl, storageToken, logger, snapshotOptions, snapshotFormatFetchType, controller, epochTracker, scenarioName) {
-    var _a;
     // back-compat: This block to be removed with #8784 when we only consume/consider odsp resolvers that are >= 0.51
     const sharingLinkToRedeem = odspResolvedUrl.sharingLinkToRedeem;
     if (sharingLinkToRedeem) {
-        odspResolvedUrl.shareLinkInfo = Object.assign(Object.assign({}, odspResolvedUrl.shareLinkInfo), { sharingLinkToRedeem });
+        odspResolvedUrl.shareLinkInfo = { ...odspResolvedUrl.shareLinkInfo, sharingLinkToRedeem };
     }
     const snapshotUrl = odspResolvedUrl.endpoints.snapshotStorageUrl;
-    const url = `${snapshotUrl}/trees/latest?ump=1`;
+    const queryParams = { ump: 1 };
+    if (snapshotOptions !== undefined) {
+        Object.entries(snapshotOptions).forEach(([key, value]) => {
+            // Exclude "timeout" from query string
+            if (value !== undefined && key !== "timeout") {
+                queryParams[key] = value;
+            }
+        });
+    }
+    const queryString = getQueryString(queryParams);
+    const url = `${snapshotUrl}/trees/latest${queryString}`;
     // The location of file can move on Spo in which case server returns 308(Permanent Redirect) error.
     // Adding below header will make VROOM API return 404 instead of 308 and browser can intercept it.
     // This error thrown by server will contain the new redirect location. Look at the 404 error parsing
     // for futher reference here: \packages\utils\odsp-doclib-utils\src\odspErrorUtils.ts
     const header = { prefer: "manualredirect" };
-    const { body, headers } = getFormBodyAndHeaders(odspResolvedUrl, storageToken, snapshotOptions, header);
+    const { body, headers } = getFormBodyAndHeaders(odspResolvedUrl, storageToken, header);
     const fetchOptions = {
         body,
         headers,
-        signal: controller === null || controller === void 0 ? void 0 : controller.signal,
+        signal: controller?.signal,
         method: "POST",
     };
     // Decide what snapshot format to fetch as per the feature gate.
     switch (snapshotFormatFetchType) {
-        case SnapshotFormatSupportType.JsonAndBinary:
-            headers.accept = `application/json, application/ms-fluid; v=${currentReadVersion}`;
-            break;
         case SnapshotFormatSupportType.Binary:
             headers.accept = `application/ms-fluid; v=${currentReadVersion}`;
             break;
         default:
-            headers.accept = "application/json";
+            // By default ask both versions and let the server decide the format.
+            headers.accept = `application/json, application/ms-fluid; v=${currentReadVersion}`;
     }
-    const odspResponse = await ((_a = epochTracker === null || epochTracker === void 0 ? void 0 : epochTracker.fetch(url, fetchOptions, "treesLatest", true, scenarioName)) !== null && _a !== void 0 ? _a : fetchHelper(url, fetchOptions));
+    const odspResponse = await (epochTracker?.fetch(url, fetchOptions, "treesLatest", true, scenarioName) ?? fetchHelper(url, fetchOptions));
     return {
         odspResponse,
         requestHeaders: headers,
@@ -390,11 +411,11 @@ export async function downloadSnapshot(odspResolvedUrl, storageToken, logger, sn
     };
 }
 function isRedeemSharingLinkError(odspResolvedUrl, error) {
-    var _a;
-    if (((_a = odspResolvedUrl.shareLinkInfo) === null || _a === void 0 ? void 0 : _a.sharingLinkToRedeem) !== undefined
-        && (typeof error === "object" && error !== null)
-        && (error.errorType === DriverErrorType.authorizationError
-            || error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError)) {
+    if (odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem !== undefined &&
+        typeof error === "object" &&
+        error !== null &&
+        (error.errorType === DriverErrorType.authorizationError ||
+            error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError)) {
         return true;
     }
     return false;
@@ -405,11 +426,8 @@ function getEncodedShareUrl(url) {
      * https://docs.microsoft.com/en-us/onedrive/developer/rest-api/api/shares_get
      */
     let encodedUrl = fromUtf8ToBase64(encodeURI(url));
-    encodedUrl = encodedUrl
-        .replace(/=+$/g, "")
-        .replace(/\//g, "_")
-        .replace(/\+/g, "-");
+    encodedUrl = encodedUrl.replace(/=+$/g, "").replace(/\//g, "_").replace(/\+/g, "-");
     encodedUrl = "u!".concat(encodedUrl);
     return encodedUrl;
 }
-//# sourceMappingURL=fetchSnapshot.js.map
+//# sourceMappingURL=fetchSnapshot.mjs.map