@fluidframework/odsp-driver 0.57.2 → 0.58.1000

package/src/epochTracker.ts

@@ -323,8 +323,6 @@ export class EpochTracker implements IPersistedFileCache {
         if (isFluidError(error) && error.errorType === DriverErrorType.fileOverwrittenInStorage) {
             const epochError = this.checkForEpochErrorCore(epochFromResponse);
             if (epochError !== undefined) {
-                assert(isFluidError(epochError),
-                    0x21f /* "epochError expected to be thrown by throwOdspNetworkError and of known type" */);
                 epochError.addTelemetryProperties({
                     fromCache,
                     clientEpoch: this.fluidEpoch,
@@ -338,7 +336,10 @@ export class EpochTracker implements IPersistedFileCache {
             // If it was categorized as epoch error but the epoch returned in response matches with the client epoch
             // then it was coherency 409, so rethrow it as throttling error so that it can retried. Default throttling
             // time is 1s.
-            throw new ThrottlingError("coherency409", error.message, 1, { [Odsp409Error]: true, driverVersion });
+            throw new ThrottlingError(
+                `Coherency 409: ${error.message}`,
+                1 /* retryAfterSeconds */,
+                { [Odsp409Error]: true, driverVersion });
         }
     }
 
@@ -350,7 +351,7 @@ export class EpochTracker implements IPersistedFileCache {
             // This is similar in nature to how fluidEpochMismatchError (409) is handled.
             // Difference - client detected mismatch, instead of server detecting it.
             return new NonRetryableError(
-                "epochMismatch", "Epoch mismatch", DriverErrorType.fileOverwrittenInStorage, { driverVersion });
+                "Epoch mismatch", DriverErrorType.fileOverwrittenInStorage, { driverVersion });
         }
     }
 

package/src/fetchSnapshot.ts

@@ -216,23 +216,33 @@ async function fetchLatestSnapshotCore(
             logger,
             perfEvent,
             async (event) => {
-                const startTime = performance.now();
                 const response = await snapshotDownloader(
                     odspResolvedUrl,
                     storageToken,
                     snapshotOptions,
                     controller,
                 );
-                const endTime = performance.now();
-                const overallTime = endTime - startTime;
                 const snapshot = response.odspSnapshotResponse.content;
-                let dnstime: number | undefined; // domainLookupEnd - domainLookupStart
-                let redirectTime: number | undefined; // redirectEnd -redirectStart
+                // 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: number | undefined; // domainLookupEnd - domainLookupStart
+                let redirectTime: number | undefined; // redirectEnd - redirectStart
                 let tcpHandshakeTime: number | undefined; // connectEnd  - connectStart
-                let secureConntime: number | undefined; // connectEnd  - secureConnectionStart
-                let responseTime: number | undefined; // responsEnd - responseStart
-                let fetchStToRespEndTime: number | undefined; // responseEnd  - fetchStart
-                let reqStToRespEndTime: number | undefined; // responseEnd - requestStart
+                let secureConnectionTime: number | undefined; // connectEnd  - secureConnectionStart
+                let responseNetworkTime: number | undefined; // responsEnd - responseStart
+                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");
 
@@ -246,17 +256,19 @@ async function fetchLatestSnapshotCore(
                     if ((resource_initiatortype.localeCompare("fetch") === 0)
                         && (resource_name.localeCompare(response.requestUrl) === 0)) {
                         redirectTime = indResTime.redirectEnd - indResTime.redirectStart;
-                        dnstime = indResTime.domainLookupEnd - indResTime.domainLookupStart;
+                        dnsLookupTime = indResTime.domainLookupEnd - indResTime.domainLookupStart;
                         tcpHandshakeTime = indResTime.connectEnd - indResTime.connectStart;
-                        secureConntime = (indResTime.secureConnectionStart > 0) ?
-                            (indResTime.connectEnd - indResTime.secureConnectionStart) : 0;
-                        responseTime = indResTime.responseEnd - indResTime.responseStart;
-                        fetchStToRespEndTime = (indResTime.fetchStart > 0) ?
-                            (indResTime.responseEnd - indResTime.fetchStart) : 0;
-                        reqStToRespEndTime = (indResTime.requestStart > 0) ?
-                            (indResTime.responseEnd - indResTime.requestStart) : 0;
-                        networkTime = (indResTime.startTime > 0) ? (indResTime.responseEnd - indResTime.startTime) : 0;
-                        if (spReqDuration) {
+                        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;
@@ -265,7 +277,6 @@ async function fetchLatestSnapshotCore(
 
                 const { numTrees, numBlobs, encodedBlobsSize } =
                     validateAndEvalBlobsAndTrees(response.odspSnapshotResponse.content);
-                const clientTime = networkTime ? overallTime - networkTime : undefined;
 
                 // 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.
@@ -303,16 +314,23 @@ async function fetchLatestSnapshotCore(
                     sequenceNumber,
                     ops: snapshot.ops?.length ?? 0,
                     headers: Object.keys(response.requestHeaders).length !== 0 ? true : undefined,
-                    redirecttime: redirectTime,
-                    dnsLookuptime: dnstime,
-                    responsenetworkTime: responseTime,
-                    tcphandshakeTime: tcpHandshakeTime,
-                    secureconnectiontime: secureConntime,
-                    fetchstarttorespendtime: fetchStToRespEndTime,
-                    reqstarttorespendtime: reqStToRespEndTime,
-                    overalltime: overallTime,
-                    networktime: networkTime,
-                    clienttime: clientTime,
+                    // 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,
                     // 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
@@ -360,7 +378,14 @@ async function fetchSnapshotContentsCoreV1(
 ): Promise<ISnapshotRequestAndResponseOptions> {
     const snapshotUrl = odspResolvedUrl.endpoints.snapshotStorageUrl;
     const url = `${snapshotUrl}/trees/latest?ump=1`;
-    const { body, headers } = getFormBodyAndHeaders(odspResolvedUrl, storageToken, snapshotOptions);
+    // 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);
+    headers.accept = "application/json";
     const fetchOptions = {
         body,
         headers,
@@ -422,6 +447,7 @@ function getFormBodyAndHeaders(
     odspResolvedUrl: IOdspResolvedUrl,
     storageToken: string,
     snapshotOptions: ISnapshotOptions | undefined,
+    headers?: {[index: string]: string},
 ) {
     const formBoundary = uuid();
     const formParams: string[] = [];
@@ -435,16 +461,23 @@ function getFormBodyAndHeaders(
             }
         });
     }
+    if (headers !== undefined) {
+        Object.entries(headers).forEach(([key, value]) => {
+            if (value !== undefined) {
+                formParams.push(`${key}: ${value}`);
+            }
+        });
+    }
     if (odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem) {
         formParams.push(`sl: ${odspResolvedUrl.shareLinkInfo?.sharingLinkToRedeem}`);
     }
     formParams.push(`_post: 1`);
     formParams.push(`\r\n--${formBoundary}--`);
     const postBody = formParams.join("\r\n");
-    const headers: {[index: string]: any} = {
+    const header: {[index: string]: any} = {
         "Content-Type": `multipart/form-data;boundary=${formBoundary}`,
     };
-    return { body: postBody, headers };
+    return { body: postBody, headers: header };
 }
 
 function validateAndEvalBlobsAndTrees(snapshot: ISnapshotContents) {

package/src/getFileLink.ts

@@ -125,7 +125,6 @@ async function getFileLinkCore(
                 if (typeof directUrl !== "string") {
                     // This will retry once in getWithRetryForTokenRefresh
                     throw new NonRetryableError(
-                        "getFileLinkCoreMalformedResponse",
                         "Malformed GetSharingInformation response",
                         DriverErrorType.incorrectServerResponse,
                         { driverVersion });
@@ -182,7 +181,6 @@ async function getFileItemLite(
                 if (!isFileItemLite(responseJson)) {
                     // This will retry once in getWithRetryForTokenRefresh
                     throw new NonRetryableError(
-                        "getFileItemLiteMalformedResponse",
                         "Malformed getFileItemLite response",
                         DriverErrorType.incorrectServerResponse,
                         { driverVersion });

package/src/odspCache.ts

@@ -113,9 +113,8 @@ export class PromiseCacheWithOneHourSlidingExpiry<T> extends PromiseCache<string
 export interface INonPersistentCache {
     /**
      * Cache of joined/joining session info
-     * This cache will use a one hour sliding expiration window.
      */
-    readonly sessionJoinCache: PromiseCacheWithOneHourSlidingExpiry<ISocketStorageDiscovery>;
+    readonly sessionJoinCache: PromiseCache<string, {entryTime: number, joinSessionResponse: ISocketStorageDiscovery}>;
 
     /**
      * Cache of resolved/resolving file URLs
@@ -134,7 +133,8 @@ export interface IOdspCache extends INonPersistentCache {
 }
 
 export class NonPersistentCache implements INonPersistentCache {
-    public readonly sessionJoinCache = new PromiseCacheWithOneHourSlidingExpiry<ISocketStorageDiscovery>();
+    public readonly sessionJoinCache =
+        new PromiseCache<string, {entryTime: number, joinSessionResponse: ISocketStorageDiscovery}>();
 
     public readonly fileUrlCache = new PromiseCache<string, IOdspResolvedUrl>();
 }

package/src/odspDocumentDeltaConnection.ts

@@ -425,7 +425,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
         this.pushCallCounter++;
         const nonce = `${this.requestOpsNoncePrefix}${this.pushCallCounter}`;
         // There should be only one flush ops in flight, kicked out by upload summary workflow
-        // That said, it could timeout, and request could be repeated, so theoretically we can
+        // That said, it could timeout and request could be repeated, so theoretically we can
         // get overlapping requests, but it should be very rare
         if (this.flushDeferred !== undefined) {
             this.logger.sendErrorEvent({ eventName: "FlushOpsTooMany" });

package/src/odspDocumentService.ts

@@ -52,7 +52,8 @@ import { pkgVersion as driverVersion } from "./packageVersion";
  */
 export class OdspDocumentService implements IDocumentService {
     private _policies: IDocumentServicePolicies;
-
+    // Timer which runs and executes the join session call after intervals.
+    private joinSessionRefreshTimer: ReturnType<typeof setTimeout> | undefined;
     /**
      * @param resolvedUrl - resolved url identifying document that will be managed by returned service instance.
      * @param getStorageToken - function that can provide the storage token. This is is also referred to as
@@ -237,27 +238,7 @@ export class OdspDocumentService implements IDocumentService {
                 ? Promise.resolve(null)
                 : this.getWebsocketToken!(options);
 
-            const joinSessionPromise = this.joinSession(requestWebsocketTokenFromJoinSession, options).catch((e) => {
-                const likelyFacetCodes = e as IFacetCodes;
-                if (Array.isArray(likelyFacetCodes.facetCodes)) {
-                    for (const code of likelyFacetCodes.facetCodes) {
-                        switch (code) {
-                            case "sessionForbiddenOnPreservedFiles":
-                            case "sessionForbiddenOnModerationEnabledLibrary":
-                            case "sessionForbiddenOnRequireCheckout":
-                                // This document can only be opened in storage-only mode.
-                                // DeltaManager will recognize this error
-                                // and load without a delta stream connection.
-                                this._policies = {...this._policies,storageOnly: true};
-                                throw new DeltaStreamConnectionForbiddenError(code, { driverVersion });
-                            default:
-                                continue;
-                        }
-                    }
-                }
-                throw e;
-            });
-
+            const joinSessionPromise = this.joinSession(requestWebsocketTokenFromJoinSession, options);
             const [websocketEndpoint, websocketToken, io] =
                 await Promise.all([
                     joinSessionPromise,
@@ -268,7 +249,6 @@ export class OdspDocumentService implements IDocumentService {
             const finalWebsocketToken = websocketToken ?? (websocketEndpoint.socketToken || null);
             if (finalWebsocketToken === null) {
                 throw new NonRetryableError(
-                    "pushTokenIsNull",
                     "Websocket token is null",
                     OdspErrorType.fetchTokenError,
                     { driverVersion });
@@ -287,6 +267,8 @@ export class OdspDocumentService implements IDocumentService {
                 // On disconnect with 401/403 error code, we can just clear the joinSession cache as we will again
                 // get the auth error on reconnecting and face latency.
                 connection.on("disconnect", (error: any) => {
+                    // Clear the join session refresh timer so that it can be restarted on reconnection.
+                    this.clearJoinSessionTimer();
                     if (typeof error === "object" && error !== null
                         && error.errorType === DriverErrorType.authorizationError) {
                         this.cache.sessionJoinCache.remove(this.joinSessionKey);
@@ -304,12 +286,59 @@ export class OdspDocumentService implements IDocumentService {
         });
     }
 
+    private clearJoinSessionTimer() {
+        if (this.joinSessionRefreshTimer !== undefined) {
+            clearTimeout(this.joinSessionRefreshTimer);
+            this.joinSessionRefreshTimer = undefined;
+        }
+    }
+
+    private async scheduleJoinSessionRefresh(delta: number) {
+        await new Promise<void>((resolve, reject) => {
+            this.joinSessionRefreshTimer = setTimeout(() => {
+                getWithRetryForTokenRefresh(async (options) => {
+                    await this.joinSession(false, options);
+                    resolve();
+                }).catch((error) => {
+                    reject(error);
+                });
+            }, delta);
+        });
+    }
+
     private async joinSession(
         requestSocketToken: boolean,
         options: TokenFetchOptionsEx,
+    ) {
+        return this.joinSessionCore(requestSocketToken, options).catch((e) => {
+            const likelyFacetCodes = e as IFacetCodes;
+            if (Array.isArray(likelyFacetCodes.facetCodes)) {
+                for (const code of likelyFacetCodes.facetCodes) {
+                    switch (code) {
+                        case "sessionForbiddenOnPreservedFiles":
+                        case "sessionForbiddenOnModerationEnabledLibrary":
+                        case "sessionForbiddenOnRequireCheckout":
+                            // This document can only be opened in storage-only mode.
+                            // DeltaManager will recognize this error
+                            // and load without a delta stream connection.
+                            this._policies = {...this._policies,storageOnly: true};
+                            throw new DeltaStreamConnectionForbiddenError(code, { driverVersion });
+                        default:
+                            continue;
+                    }
+                }
+            }
+            throw e;
+        });
+    }
+
+    private async joinSessionCore(
+        requestSocketToken: boolean,
+        options: TokenFetchOptionsEx,
     ): Promise<ISocketStorageDiscovery> {
-        const executeFetch = async () =>
-            fetchJoinSession(
+        const disableJoinSessionRefresh = this.mc.config.getBoolean("Fluid.Driver.Odsp.disableJoinSessionRefresh");
+        const executeFetch = async () => {
+            const joinSessionResponse = await fetchJoinSession(
                 this.odspResolvedUrl,
                 "opStream/joinSession",
                 "POST",
@@ -318,12 +347,65 @@ export class OdspDocumentService implements IDocumentService {
                 this.epochTracker,
                 requestSocketToken,
                 options,
+                disableJoinSessionRefresh,
                 this.hostPolicy.sessionOptions?.unauthenticatedUserDisplayName,
             );
+            return {
+                entryTime: Date.now(),
+                joinSessionResponse,
+            };
+        };
+
+        const getResponseAndRefreshAfterDeltaMs = async () => {
+            let response = await this.cache.sessionJoinCache.addOrGet(this.joinSessionKey, executeFetch);
+            // If the response does not contain refreshSessionDurationSeconds, then treat it as old flow and let the
+            // cache entry to be treated as expired after 1 hour.
+            response.joinSessionResponse.refreshSessionDurationSeconds =
+                response.joinSessionResponse.refreshSessionDurationSeconds ?? 3600;
+            return {
+                ...response,
+                refreshAfterDeltaMs: this.calculateJoinSessionRefreshDelta(
+                    response.entryTime, response.joinSessionResponse.refreshSessionDurationSeconds),
+            }
+        };
+        let response = await getResponseAndRefreshAfterDeltaMs();
+        // This means that the cached entry has expired(This should not be possible if the response is fetched
+        // from the network call). In this case we remove the cached entry and fetch the new response.
+        if (response.refreshAfterDeltaMs <= 0) {
+            this.cache.sessionJoinCache.remove(this.joinSessionKey);
+            response = await getResponseAndRefreshAfterDeltaMs();
+        }
+        if (!disableJoinSessionRefresh) {
+            const props = {
+                entryTime: response.entryTime,
+                refreshSessionDurationSeconds:
+                    response.joinSessionResponse.refreshSessionDurationSeconds,
+                refreshAfterDeltaMs: response.refreshAfterDeltaMs,
+            };
+            if (response.refreshAfterDeltaMs > 0) {
+                this.scheduleJoinSessionRefresh(response.refreshAfterDeltaMs)
+                    .catch((error) => {
+                        this.mc.logger.sendErrorEvent({
+                                eventName: "JoinSessionRefreshError",
+                                ...props,
+                            },
+                            error,
+                        )
+                    });;
+            } else {
+                // Logging just for informational purposes to help with debugging as this is a new feature.
+                this.mc.logger.sendErrorEvent({
+                    eventName: "JoinSessionRefreshNotScheduled",
+                    ...props,
+                });
+            }
+        }
+        return response.joinSessionResponse;
+    }
 
-        // Note: The sessionCache is configured with a sliding expiry of 1 hour,
-        // so if we've fetched the join session within the last hour we won't run executeFetch again now.
-        return this.cache.sessionJoinCache.addOrGet(this.joinSessionKey, executeFetch);
+    private calculateJoinSessionRefreshDelta(responseFetchTime: number, refreshSessionDurationSeconds: number) {
+        // 30 seconds is buffer time to refresh the session.
+        return responseFetchTime + ((refreshSessionDurationSeconds * 1000) - 30000) - Date.now();
     }
 
     /**

package/src/odspDocumentStorageManager.ts

@@ -529,15 +529,13 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
             const versionsResponse = response.content;
             if (!versionsResponse) {
                 throw new NonRetryableError(
-                    "getVersionsReturnedNoResponse",
                     "No response from /versions endpoint",
                     DriverErrorType.genericNetworkError,
                     { driverVersion });
             }
             if (!Array.isArray(versionsResponse.value)) {
                 throw new NonRetryableError(
-                    "getVersionsReturnedNonArrayResponse",
-                    "Incorrect response from /versions endpoint",
+                    "Incorrect response from /versions endpoint, expected an array",
                     DriverErrorType.genericNetworkError,
                     { driverVersion });
             }
@@ -714,7 +712,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
     private checkSnapshotUrl() {
         if (!this.snapshotUrl) {
             throw new NonRetryableError(
-                "noSnapshotUrlProvided",
                 "Method failed because no snapshot url was available",
                 DriverErrorType.genericError,
                 { driverVersion });
@@ -724,7 +721,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
     private checkAttachmentPOSTUrl() {
         if (!this.attachmentPOSTUrl) {
             throw new NonRetryableError(
-                "noAttachmentPOSTUrlProvided",
                 "Method failed because no attachment POST url was available",
                 DriverErrorType.genericError,
                 { driverVersion });
@@ -734,7 +730,6 @@ export class OdspDocumentStorageService implements IDocumentStorageService {
     private checkAttachmentGETUrl() {
         if (!this.attachmentGETUrl) {
             throw new NonRetryableError(
-                "noAttachmentGETUrlWasProvided",
                 "Method failed because no attachment GET url was available",
                 DriverErrorType.genericError,
                 { driverVersion });

package/src/odspDriverUrlResolver.ts

@@ -5,7 +5,12 @@
 
 import { assert } from "@fluidframework/common-utils";
 import { IFluidCodeDetails, IRequest, isFluidPackage } from "@fluidframework/core-interfaces";
-import { DriverHeader, IResolvedUrl, IUrlResolver } from "@fluidframework/driver-definitions";
+import {
+    DriverHeader,
+    IContainerPackageInfo,
+    IResolvedUrl,
+    IUrlResolver,
+} from "@fluidframework/driver-definitions";
 import { IOdspResolvedUrl, ShareLinkTypes, ShareLinkInfoType } from "@fluidframework/odsp-driver-definitions";
 import { createOdspUrl } from "./createOdspUrl";
 import { getApiRoot } from "./odspUrlHelper";
@@ -151,16 +156,24 @@ export class OdspDriverUrlResolver implements IUrlResolver {
     public async getAbsoluteUrl(
         resolvedUrl: IResolvedUrl,
         relativeUrl: string,
-        codeDetails?: IFluidCodeDetails,
+        packageInfoSource?: IContainerPackageInfo | IFluidCodeDetails,
     ): Promise<string> {
         let dataStorePath = relativeUrl;
         if (dataStorePath.startsWith("/")) {
             dataStorePath = dataStorePath.substr(1);
         }
         const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
-        const containerPackageName =
-            isFluidPackage(codeDetails?.package) ? codeDetails?.package.name : codeDetails?.package ??
-            odspResolvedUrl.codeHint?.containerPackageName;
+
+        // back-compat: IFluidCodeDetails usage to be removed in 0.58.0
+        let containerPackageName;
+        if (packageInfoSource && "name" in packageInfoSource) {
+            containerPackageName = packageInfoSource.name
+        } else if (isFluidPackage(packageInfoSource?.package)) {
+            containerPackageName = packageInfoSource?.package.name
+        } else {
+            containerPackageName = packageInfoSource?.package
+        }
+        containerPackageName = containerPackageName ?? odspResolvedUrl.codeHint?.containerPackageName
 
         return createOdspUrl({
             ... odspResolvedUrl,

package/src/odspDriverUrlResolverForShareLink.ts

@@ -5,7 +5,11 @@
 
 import { PromiseCache } from "@fluidframework/common-utils";
 import { IFluidCodeDetails, IRequest, isFluidPackage } from "@fluidframework/core-interfaces";
-import { IResolvedUrl, IUrlResolver } from "@fluidframework/driver-definitions";
+import {
+    IContainerPackageInfo,
+    IResolvedUrl,
+    IUrlResolver,
+} from "@fluidframework/driver-definitions";
 import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { NonRetryableError } from "@fluidframework/driver-utils";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
@@ -164,8 +168,7 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
                 async (event) => tokenFetcher(options).then((tokenResponse) => {
                     if (tokenResponse === null) {
                         throw new NonRetryableError(
-                            "shareLinkTokenIsNull",
-                            "Token callback returned null",
+                            "Token callback returned null for share link",
                             OdspErrorType.fetchTokenError,
                             { driverVersion });
                     }
@@ -214,17 +217,22 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
     public async getAbsoluteUrl(
         resolvedUrl: IResolvedUrl,
         dataStorePath: string,
-        codeDetails?: IFluidCodeDetails,
+        packageInfoSource?: IContainerPackageInfo | IFluidCodeDetails,
     ): Promise<string> {
         const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
-
         const shareLink = await this.getShareLinkPromise(odspResolvedUrl);
-
         const shareLinkUrl = new URL(shareLink);
 
-        const containerPackageName =
-            isFluidPackage(codeDetails?.package) ? codeDetails?.package.name : codeDetails?.package ??
-            odspResolvedUrl.codeHint?.containerPackageName;
+        // back-compat: IFluidCodeDetails usage to be removed in 0.58.0
+        let containerPackageName;
+        if (packageInfoSource && "name" in packageInfoSource) {
+            containerPackageName = packageInfoSource.name
+        } else if (isFluidPackage(packageInfoSource?.package)) {
+            containerPackageName = packageInfoSource?.package.name
+        } else {
+            containerPackageName = packageInfoSource?.package
+        }
+        containerPackageName = containerPackageName ?? odspResolvedUrl.codeHint?.containerPackageName
 
         storeLocatorInOdspUrl(shareLinkUrl, {
             siteUrl: odspResolvedUrl.siteUrl,

package/src/odspError.ts

@@ -10,9 +10,8 @@ import { IOdspSocketError } from "./contracts";
  * Returns network error based on error object from ODSP socket (IOdspSocketError)
  */
 export function errorObjectFromSocketError(socketError: IOdspSocketError, handler: string) {
-    const message = `OdspSocketError (${handler}): ${socketError.message}`;
+    const message = `ODSP socket error (${handler}): ${socketError.message}`;
     const error = createOdspNetworkError(
-        `odspSocketError [${handler}]`,
         message,
         socketError.code,
         socketError.retryAfter);