@fluidframework/odsp-driver 0.52.1 → 0.54.0

package/src/odspDocumentService.ts

@@ -5,7 +5,11 @@
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { performance } from "@fluidframework/common-utils";
-import { ChildLogger, TelemetryLogger } from "@fluidframework/telemetry-utils";
+import {
+    ChildLogger,
+    loggerToMonitoringContext,
+    MonitoringContext,
+} from "@fluidframework/telemetry-utils";
 import {
     IDocumentDeltaConnection,
     IDocumentDeltaStorageService,
@@ -14,8 +18,8 @@ import {
     IDocumentStorageService,
     IDocumentServicePolicies,
 } from "@fluidframework/driver-definitions";
-import { DeltaStreamConnectionForbiddenError } from "@fluidframework/driver-utils";
-import { fetchTokenErrorCode, IFacetCodes, throwOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { DeltaStreamConnectionForbiddenError, NonRetryableError } from "@fluidframework/driver-utils";
+import { IFacetCodes } from "@fluidframework/odsp-doclib-utils";
 import {
     IClient,
     ISequencedDocumentMessage,
@@ -26,6 +30,7 @@ import {
     IEntry,
     HostStoragePolicy,
     InstrumentedStorageTokenFetcher,
+    OdspErrorType,
 } from "@fluidframework/odsp-driver-definitions";
 import { HostStoragePolicyInternal, ISocketStorageDiscovery } from "./contracts";
 import { IOdspCache } from "./odspCache";
@@ -39,18 +44,6 @@ import { EpochTracker } from "./epochTracker";
 import { OpsCache } from "./opsCaching";
 import { RetryErrorsStorageAdapter } from "./retryErrorsStorageAdapter";
 
-// Gate that when set to "1", instructs to fetch the binary format snapshot from the spo.
-function gatesBinaryFormatSnapshot() {
-    try {
-        if (typeof localStorage === "object" && localStorage !== null) {
-            if  (localStorage.binaryFormatSnapshot === "1") {
-                return true;
-            }
-        }
-    } catch (e) {}
-    return false;
-}
-
 /**
  * The DocumentService manages the Socket.IO connection and manages routing requests to connected
  * clients
@@ -98,7 +91,7 @@ export class OdspDocumentService implements IDocumentService {
 
     private storageManager?: OdspDocumentStorageService;
 
-    private readonly logger: TelemetryLogger;
+    private readonly mc: MonitoringContext;
 
     private readonly joinSessionKey: string;
 
@@ -139,16 +132,18 @@ export class OdspDocumentService implements IDocumentService {
         };
 
         this.joinSessionKey = `${this.odspResolvedUrl.hashedDocumentId}/joinsession`;
-        this.logger = ChildLogger.create(logger,
+        this.mc = loggerToMonitoringContext(
+            ChildLogger.create(logger,
             undefined,
             {
                 all: {
                     odc: isOdcOrigin(new URL(this.odspResolvedUrl.endpoints.snapshotStorageUrl).origin),
                 },
-            });
+            }));
 
         this.hostPolicy = hostPolicy;
-        this.hostPolicy.fetchBinarySnapshotFormat ??= gatesBinaryFormatSnapshot();
+        this.hostPolicy.fetchBinarySnapshotFormat ??=
+            this.mc.config.getBoolean("Fluid.Driver.Odsp.binaryFormatSnapshot");
         if (this.odspResolvedUrl.summarizer) {
             this.hostPolicy = { ...this.hostPolicy, summarizerClient: true };
         }
@@ -171,7 +166,7 @@ export class OdspDocumentService implements IDocumentService {
             this.storageManager = new OdspDocumentStorageService(
                 this.odspResolvedUrl,
                 this.getStorageToken,
-                this.logger,
+                this.mc.logger,
                 true,
                 this.cache,
                 this.hostPolicy,
@@ -186,7 +181,7 @@ export class OdspDocumentService implements IDocumentService {
             );
         }
 
-        return new RetryErrorsStorageAdapter(this.storageManager, this.logger);
+        return new RetryErrorsStorageAdapter(this.storageManager, this.mc.logger);
     }
 
     /**
@@ -200,7 +195,7 @@ export class OdspDocumentService implements IDocumentService {
             this.odspResolvedUrl.endpoints.deltaStorageUrl,
             this.getStorageToken,
             this.epochTracker,
-            this.logger,
+            this.mc.logger,
         );
 
         // batch size, please see issue #5211 for data around batch sizing
@@ -208,10 +203,10 @@ export class OdspDocumentService implements IDocumentService {
         const concurrency = this.hostPolicy.concurrentOpsBatches ?? 1;
         return new OdspDeltaStorageWithCache(
             snapshotOps,
-            this.logger,
+            this.mc.logger,
             batchSize,
             concurrency,
-            async (from, to, telemetryProps) => service.get(from, to, telemetryProps),
+            async (from, to, telemetryProps, fetchReason) => service.get(from, to, telemetryProps, fetchReason),
             async (from, to) => {
                 const res = await this.opsCache?.get(from, to);
                 return res as ISequencedDocumentMessage[] ?? [];
@@ -270,7 +265,10 @@ export class OdspDocumentService implements IDocumentService {
 
             const finalWebsocketToken = websocketToken ?? (websocketEndpoint.socketToken || null);
             if (finalWebsocketToken === null) {
-                throwOdspNetworkError("pushTokenIsNull", fetchTokenErrorCode);
+                throw new NonRetryableError(
+                    "pushTokenIsNull",
+                    "Websocket token is null",
+                    OdspErrorType.fetchTokenError);
             }
             try {
                 const connection = await this.connectToDeltaStreamWithRetry(
@@ -304,7 +302,7 @@ export class OdspDocumentService implements IDocumentService {
                 this.odspResolvedUrl,
                 "opStream/joinSession",
                 "POST",
-                this.logger,
+                this.mc.logger,
                 this.getStorageToken,
                 this.epochTracker,
                 requestSocketToken,
@@ -344,7 +342,7 @@ export class OdspDocumentService implements IDocumentService {
             io,
             client,
             webSocketUrl,
-            this.logger,
+            this.mc.logger,
             60000,
             this.epochTracker,
             this.socketReferenceKeyPrefix,
@@ -354,7 +352,7 @@ export class OdspDocumentService implements IDocumentService {
         // Given that most reconnects result in reusing socket and happen very quickly,
         // report event only if it took longer than threshold.
         if (duration >= 2000) {
-            this.logger.sendPerformanceEvent({
+            this.mc.logger.sendPerformanceEvent({
                 eventName: "ConnectionSuccess",
                 duration,
             });
@@ -391,7 +389,7 @@ export class OdspDocumentService implements IDocumentService {
         };
         this._opsCache = new OpsCache(
             seqNumber,
-            this.logger,
+            this.mc.logger,
             // ICache
             {
                 write: async (key: string, opsData: string) => {

package/src/odspDocumentStorageManager.ts

@@ -17,9 +17,9 @@ import {
     ISummaryContext,
     IDocumentStorageService,
     LoaderCachingPolicy,
+    DriverErrorType,
 } from "@fluidframework/driver-definitions";
-import { RateLimiter } from "@fluidframework/driver-utils";
-import { throwOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
 import {
     IOdspResolvedUrl,
     ISnapshotOptions,
@@ -313,9 +313,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
             this.blobCache.setBlob(blobId, blob);
         }
 
-        if (!this.attributesBlobHandles.has(blobId)) {
-            return blob;
-        }
         return blob;
     }
 
@@ -406,22 +403,31 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                 { eventName: "ObtainSnapshot" },
                 async (event: PerformanceEvent) => {
                     const props = {};
-                    let cachedSnapshot: ISnapshotContents | undefined;
+                    let retrievedSnapshot: ISnapshotContents | undefined;
+                    // Here's the logic to grab the persistent cache snapshot implemented by the host
+                    // Epoch tracker is responsible for communicating with the persistent cache, handling epochs and cache versions
                     const cachedSnapshotP: Promise<ISnapshotContents | undefined> =
                         this.epochTracker.get(createCacheSnapshotKey(this.odspResolvedUrl))
-                            .then((snapshotCachedEntry: ISnapshotCachedEntry) => {
+                            .then(async (snapshotCachedEntry: ISnapshotCachedEntry) => {
                                 if (snapshotCachedEntry !== undefined) {
                                     // If the cached entry does not contain the entry time, then assign it a default of 30 days old.
-                                    // eslint-disable-next-line @typescript-eslint/dot-notation
-                                    props["cacheEntryAge"] = Date.now() - (snapshotCachedEntry.cacheEntryTime ??
+                                    const age = Date.now() - (snapshotCachedEntry.cacheEntryTime ??
                                         (Date.now() - 30 * 24 * 60 * 60 * 1000));
+
+                                    // Record the cache age
+                                    // eslint-disable-next-line @typescript-eslint/dot-notation
+                                    props["cacheEntryAge"] = age;
                                 }
+
                                 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 snapshotP = this.fetchSnapshot(hostSnapshotOptions);
+                        const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions);
 
                         // Ensure that failures on both paths are ignored initially.
                         // I.e. if cache fails for some reason, we will proceed with network result.
@@ -429,20 +435,20 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         // do want to attempt to succeed with cached data!
                         const promiseRaceWinner = await promiseRaceWithWinner([
                             cachedSnapshotP.catch(() => undefined),
-                            snapshotP.catch(() => undefined),
+                            networkSnapshotP.catch(() => undefined),
                         ]);
-                        cachedSnapshot = promiseRaceWinner.value;
+                        retrievedSnapshot = promiseRaceWinner.value;
                         method = promiseRaceWinner.index === 0 ? "cache" : "network";
 
-                        if (cachedSnapshot === undefined) {
+                        if (retrievedSnapshot === undefined) {
                             // if network failed -> wait for cache ( then return network failure)
                             // If cache returned empty or failed -> wait for network (success of failure)
                             if (promiseRaceWinner.index === 1) {
-                                cachedSnapshot = await cachedSnapshotP;
+                                retrievedSnapshot = await cachedSnapshotP;
                                 method = "cache";
                             }
-                            if (cachedSnapshot === undefined) {
-                                cachedSnapshot = await snapshotP;
+                            if (retrievedSnapshot === undefined) {
+                                retrievedSnapshot = await networkSnapshotP;
                                 method = "network";
                             }
                         }
@@ -450,12 +456,12 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         // Note: There's a race condition here - another caller may come past the undefined check
                         // while the first caller is awaiting later async code in this block.
 
-                        cachedSnapshot = await cachedSnapshotP;
+                        retrievedSnapshot = await cachedSnapshotP;
 
-                        method = cachedSnapshot !== undefined ? "cache" : "network";
+                        method = retrievedSnapshot !== undefined ? "cache" : "network";
 
-                        if (cachedSnapshot === undefined) {
-                            cachedSnapshot = await this.fetchSnapshot(hostSnapshotOptions);
+                        if (retrievedSnapshot === undefined) {
+                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions);
                         }
                     }
                     if (method === "network") {
@@ -463,12 +469,11 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
                         props["cacheEntryAge"] = undefined;
                     }
                     event.end({ ...props, method });
-                    return cachedSnapshot;
+                    return retrievedSnapshot;
                 },
-                {end: true, cancel: "error"},
             );
 
-            // Successful call, redirect future calls to getVersion only!
+            // Successful call, make network calls only
             this.firstVersionCall = false;
 
             this._snapshotSequenceNumber = odspSnapshotCacheValue.sequenceNumber;
@@ -503,10 +508,16 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
             );
             const versionsResponse = response.content;
             if (!versionsResponse) {
-                throwOdspNetworkError("getVersionsReturnedNoResponse", 400);
+                throw new NonRetryableError(
+                    "getVersionsReturnedNoResponse",
+                    "No response from /versions endpoint",
+                    DriverErrorType.genericNetworkError);
             }
             if (!Array.isArray(versionsResponse.value)) {
-                throwOdspNetworkError("getVersionsReturnedNonArrayResponse", 400);
+                throw new NonRetryableError(
+                    "getVersionsReturnedNonArrayResponse",
+                    "Incorrect response from /versions endpoint",
+                    DriverErrorType.genericNetworkError);
             }
             return versionsResponse.value.map((version) => {
                 // Parse the date from the message
@@ -678,19 +689,28 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
 
     private checkSnapshotUrl() {
         if (!this.snapshotUrl) {
-            throwOdspNetworkError("methodNotSupportedBecauseNoSnapshotUrlWasProvided", 400);
+            throw new NonRetryableError(
+                "noSnapshotUrlProvided",
+                "Method failed because no snapshot url was available",
+                DriverErrorType.genericError);
         }
     }
 
     private checkAttachmentPOSTUrl() {
         if (!this.attachmentPOSTUrl) {
-            throwOdspNetworkError("methodNotSupportedBecauseNoAttachmentPOSTUrlWasProvided", 400);
+            throw new NonRetryableError(
+                "noAttachmentPOSTUrlProvided",
+                "Method failed because no attachment POST url was available",
+                DriverErrorType.genericError);
         }
     }
 
     private checkAttachmentGETUrl() {
         if (!this.attachmentGETUrl) {
-            throwOdspNetworkError("methodNotSupportedBecauseNoAttachmentGETUrlWasProvided", 400);
+            throw new NonRetryableError(
+                "noAttachmentGETUrlWasProvided",
+                "Method failed because no attachment GET url was available",
+                DriverErrorType.genericError);
         }
     }
 

package/src/odspDriverUrlResolverForShareLink.ts

@@ -7,7 +7,7 @@ import { PromiseCache } from "@fluidframework/common-utils";
 import { IFluidCodeDetails, IRequest, isFluidPackage } from "@fluidframework/core-interfaces";
 import { IResolvedUrl, IUrlResolver } from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { fetchTokenErrorCode, throwOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { NonRetryableError } from "@fluidframework/driver-utils";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import {
     IOdspResolvedUrl,
@@ -15,6 +15,7 @@ import {
     isTokenFromCache,
     OdspResourceTokenFetchOptions,
     TokenFetcher,
+    OdspErrorType,
 } from "@fluidframework/odsp-driver-definitions";
 import {
     getLocatorFromOdspUrl,
@@ -132,8 +133,9 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
             // We need to remove the nav param if set by host when setting the sharelink as otherwise the shareLinkId
             // when redeeming the share link during the redeem fallback for trees latest call becomes greater than
             // the eligible length.
+            odspResolvedUrl.sharingLinkToRedeem = this.removeNavParam(request.url);
             odspResolvedUrl.shareLinkInfo = Object.assign(odspResolvedUrl.shareLinkInfo || {},
-                {sharingLinkToRedeem: this.removeNavParam(request.url)});
+                {sharingLinkToRedeem: odspResolvedUrl.sharingLinkToRedeem});
         }
         if (odspResolvedUrl.itemId) {
             // Kick start the sharing link request if we don't have it already as a performance optimization.
@@ -161,7 +163,10 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
                 { eventName: "GetSharingLinkToken" },
                 async (event) => tokenFetcher(options).then((tokenResponse) => {
                     if (tokenResponse === null) {
-                        throwOdspNetworkError("shareLinkTokenIsNull", fetchTokenErrorCode);
+                        throw new NonRetryableError(
+                            "shareLinkTokenIsNull",
+                            "Token callback returned null",
+                            OdspErrorType.fetchTokenError);
                     }
                     event.end({ fromCache: isTokenFromCache(tokenResponse) });
                     return tokenResponse;

package/src/odspError.ts

@@ -11,9 +11,13 @@ import { IOdspSocketError } from "./contracts";
  */
 export function errorObjectFromSocketError(socketError: IOdspSocketError, handler: string) {
     const message = `OdspSocketError (${handler}): ${socketError.message}`;
-    return createOdspNetworkError(
+    const error = createOdspNetworkError(
         `odspSocketError [${handler}]`,
         message,
         socketError.code,
         socketError.retryAfter);
+
+    error.addTelemetryProperties({ odspError: true, relayServiceError: true });
+
+    return error;
 }

package/src/odspSummaryUploadManager.ts

@@ -9,7 +9,7 @@ import { ISummaryContext } from "@fluidframework/driver-definitions";
 import { getGitType } from "@fluidframework/protocol-base";
 import * as api from "@fluidframework/protocol-definitions";
 import { InstrumentedStorageTokenFetcher } from "@fluidframework/odsp-driver-definitions";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { loggerToMonitoringContext, MonitoringContext, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import {
     IOdspSummaryPayload,
     IWriteSummaryResponse,
@@ -24,23 +24,6 @@ import { getWithRetryForTokenRefresh } from "./odspUtils";
 
 /* eslint-disable max-len */
 
-// Gate that when flipped, instructs to mark unreferenced nodes as such in the summary sent to SPO.
-function gatesMarkUnreferencedNodes() {
-    try {
-        // Leave override for testing purposes
-        if (typeof localStorage === "object" && localStorage !== null) {
-            if  (localStorage.FluidMarkUnreferencedNodes === "1") {
-                return true;
-            }
-            if  (localStorage.FluidMarkUnreferencedNodes === "0") {
-                return false;
-            }
-        }
-    } catch (e) {}
-
-    return true;
-}
-
 /**
  * This class manages a summary upload. When it receives a call to upload summary, it converts the summary tree into
  * a snapshot tree and then uploads that to the server.
@@ -48,20 +31,22 @@ function gatesMarkUnreferencedNodes() {
 export class OdspSummaryUploadManager {
     // Last proposed handle of the uploaded app summary.
     private lastSummaryProposalHandle: string | undefined;
+    private readonly mc: MonitoringContext;
 
     constructor(
         private readonly snapshotUrl: string,
         private readonly getStorageToken: InstrumentedStorageTokenFetcher,
-        private readonly logger: ITelemetryLogger,
+        logger: ITelemetryLogger,
         private readonly epochTracker: EpochTracker,
     ) {
+        this.mc = loggerToMonitoringContext(logger);
     }
 
     public async writeSummaryTree(tree: api.ISummaryTree, context: ISummaryContext) {
         // If the last proposed handle is not the proposed handle of the acked summary(could happen when the last summary get nacked),
         // then re-initialize the caches with the previous ones else just update the previous caches with the caches from acked summary.
         if (context.proposalHandle !== this.lastSummaryProposalHandle) {
-            this.logger.sendTelemetryEvent({
+            this.mc.logger.sendTelemetryEvent({
                 eventName: "LastSummaryProposedHandleMismatch",
                 ackedSummaryProposedHandle: context.proposalHandle,
                 lastSummaryProposalHandle: this.lastSummaryProposalHandle,
@@ -107,7 +92,7 @@ export class OdspSummaryUploadManager {
 
             const postBody = JSON.stringify(snapshot);
 
-            return PerformanceEvent.timedExecAsync(this.logger,
+            return PerformanceEvent.timedExecAsync(this.mc.logger,
                 {
                     eventName: "uploadSummary",
                     attempt: options.refresh ? 2 : 1,
@@ -145,7 +130,7 @@ export class OdspSummaryUploadManager {
         tree: api.ISummaryTree,
         rootNodeName: string,
         path: string = "",
-        markUnreferencedNodes: boolean = gatesMarkUnreferencedNodes(),
+        markUnreferencedNodes: boolean = this.mc.config.getBoolean("Fluid.Driver.Odsp.MarkUnreferencedNodes") ?? true,
     ) {
         const snapshotTree: IOdspSummaryTree = {
             type: "tree",

package/src/odspUtils.ts

@@ -5,19 +5,14 @@
 
 import { ITelemetryProperties, ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { IResolvedUrl, DriverErrorType } from "@fluidframework/driver-definitions";
-import { isOnline, OnlineStatus } from "@fluidframework/driver-utils";
+import { isOnline, OnlineStatus, RetryableError, NonRetryableError } from "@fluidframework/driver-utils";
 import { assert, performance } from "@fluidframework/common-utils";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 import { ChildLogger, PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
 import {
     fetchIncorrectResponse,
-    offlineFetchFailureStatusCode,
-    fetchFailureStatusCode,
-    fetchTimeoutStatusCode,
     throwOdspNetworkError,
     getSPOAndGraphRequestIdsFromResponse,
-    fetchTokenErrorCode,
-    createOdspNetworkError,
 } from "@fluidframework/odsp-doclib-utils";
 import {
     IOdspResolvedUrl,
@@ -82,7 +77,7 @@ export async function getWithRetryForTokenRefresh<T>(get: (options: TokenFetchOp
             case DriverErrorType.authorizationError:
                 return get({ ...options, claims: e.claims, tenantId: e.tenantId });
 
-            case DriverErrorType.incorrectServerResponse: // fetchIncorrectResponse - some error on the wire, retry once
+            case DriverErrorType.incorrectServerResponse: // some error on the wire, retry once
             case OdspErrorType.fetchTokenError: // If the token was null, then retry once.
                 return get(options);
 
@@ -107,7 +102,10 @@ export async function fetchHelper(
         const response = fetchResponse as any as Response;
         // Let's assume we can retry.
         if (!response) {
-            throwOdspNetworkError("odspFetchErrorNoResponse", fetchIncorrectResponse);
+            throw new NonRetryableError(
+                "odspFetchErrorNoResponse",
+                "No response from fetch call",
+                DriverErrorType.incorrectServerResponse);
         }
         if (!response.ok || response.status < 200 || response.status >= 300) {
             throwOdspNetworkError(
@@ -130,11 +128,13 @@ export async function fetchHelper(
         if (errorText === "TypeError: Failed to fetch") {
             online = OnlineStatus.Offline;
         }
+        // This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
         if (error.name === "AbortError") {
-            throwOdspNetworkError("timeoutDuringFetch", fetchTimeoutStatusCode);
+            throw new RetryableError("fetchAbort", "Fetch Timeout (AbortError)", OdspErrorType.fetchTimeout);
         }
+        // TCP/IP timeout
         if (errorText.indexOf("ETIMEDOUT") !== -1) {
-            throwOdspNetworkError("timeoutDuringFetch(ETIMEDOUT)", fetchTimeoutStatusCode);
+            throw new RetryableError("fetchETimedout", "Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout);
         }
 
         //
@@ -142,11 +142,11 @@ export async function fetchHelper(
         // It could container PII, like URI in message itself, or token in properties.
         // It is also non-serializable object due to circular references.
         //
-        const failureCode = online === OnlineStatus.Offline ? offlineFetchFailureStatusCode : fetchFailureStatusCode;
-        throwOdspNetworkError(
-            `odspFetchThrewError [${failureCode}]`,
-            failureCode,
-        );
+        if (online === OnlineStatus.Offline) {
+            throw new RetryableError("OdspFetchOffline", `Offline: ${errorText}`, DriverErrorType.offlineError);
+        } else {
+            throw new RetryableError("OdspFetchError", `Fetch error: ${errorText}`, DriverErrorType.fetchFailure);
+        }
     });
 }
 
@@ -181,30 +181,31 @@ export async function fetchAndParseAsJSONHelper<T>(
     requestInit: RequestInit | undefined,
 ): Promise<IOdspResponse<T>> {
     const { content, headers, commonSpoHeaders, duration } = await fetchHelper(requestInfo, requestInit);
-    // JSON.parse() can fail and message (that goes into telemetry) would container full request URI, including
-    // tokens... It fails for me with "Unexpected end of JSON input" quite often - an attempt to download big file
-    // (many ops) almost always ends up with this error - I'd guess 1% of op request end up here... It always
-    // succeeds on retry.
+    let text: string | undefined;
     try {
-        const text = await content.text();
-
-        commonSpoHeaders.bodySize = text.length;
-        const res = {
-            headers,
-            content: JSON.parse(text),
-            commonSpoHeaders,
-            duration,
-        };
-        return res;
+        text = await content.text();
     } catch (e) {
+        // JSON.parse() can fail and message would container full request URI, including
+        // tokens... It fails for me with "Unexpected end of JSON input" quite often - an attempt to download big file
+        // (many ops) almost always ends up with this error - I'd guess 1% of op request end up here... It always
+        // succeeds on retry.
+        // So do not log error object itself.
         throwOdspNetworkError(
             "errorWhileParsingFetchResponse",
             fetchIncorrectResponse,
-            content,
-            undefined,
-            { error: Object(e) },
+            content, // response
+            text,
         );
     }
+
+    commonSpoHeaders.bodySize = text.length;
+    const res = {
+        headers,
+        content: JSON.parse(text),
+        commonSpoHeaders,
+        duration,
+    };
+    return res;
 }
 
 export interface INewFileInfo {
@@ -293,13 +294,21 @@ export function toInstrumentedOdspTokenFetcher(
                     event.end({ fromCache: isTokenFromCache(tokenResponse), isNull: token === null });
                 }
                 if (token === null && throwOnNullToken) {
-                    throwOdspNetworkError("tokenIsNull", fetchTokenErrorCode, undefined, undefined, { method: name });
+                    throw new NonRetryableError(
+                        "storageTokenIsNull",
+                        `Token is null for ${name} call`,
+                        OdspErrorType.fetchTokenError,
+                        { method: name });
                 }
                 return token;
             }, (error) => {
                 const tokenError = wrapError(
                     error,
-                    (errorMessage) => createOdspNetworkError("tokenFetcherFailed", errorMessage, fetchTokenErrorCode));
+                    (errorMessage) => new NonRetryableError(
+                        "tokenFetcherFailed",
+                        errorMessage,
+                        OdspErrorType.fetchTokenError,
+                        { method: name }));
                 throw tokenError;
             }),
             { cancel: "generic" });

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "0.52.1";
+export const pkgVersion = "0.54.0";

package/src/vroom.ts

@@ -88,11 +88,16 @@ export async function fetchJoinSession(
                 logger,
             );
 
+            const socketUrl = response.content.deltaStreamSocketUrl;
+            // expecting socketUrl to be something like https://{hostName}/...
+            const webSocketHostName = socketUrl.split("/")[2];
+
             // TODO SPO-specific telemetry
             event.end({
                 ...response.commonSpoHeaders,
                 // pushV2 websocket urls will contain pushf
-                pushv2: response.content.deltaStreamSocketUrl.includes("pushf"),
+                pushv2: socketUrl.includes("pushf"),
+                webSocketHostName,
             });
 
             if (response.content.runtimeTenantId && !response.content.tenantId) {