@fluidframework/odsp-driver 1.2.1 → 2.0.0-internal.1.0.0

package/src/odspDocumentStorageManager.ts

@@ -16,6 +16,7 @@ import * as api from "@fluidframework/protocol-definitions";
 import {
     ISummaryContext,
     DriverErrorType,
+    FetchSource,
 } from "@fluidframework/driver-definitions";
 import { RateLimiter, NonRetryableError } from "@fluidframework/driver-utils";
 import {
@@ -92,6 +93,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         private readonly hostPolicy: HostStoragePolicyInternal,
         private readonly epochTracker: EpochTracker,
         private readonly flushCallback: () => Promise<FlushResult>,
+        private readonly relayServiceTenantAndSessionId: () => string,
         private readonly snapshotFormatFetchType?: SnapshotFormatSupportType,
     ) {
         super();
@@ -107,6 +109,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
             logger,
             epochTracker,
             !!this.hostPolicy.sessionOptions?.forceAccessTokenViaAuthorizationHeader,
+            this.relayServiceTenantAndSessionId,
         );
     }
 
@@ -204,7 +207,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
         return super.getSnapshotTree(version, scenarioName);
     }
 
-    public async getVersions(blobid: string | null, count: number, scenarioName?: string): Promise<api.IVersion[]> {
+    public async getVersions(blobid: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<api.IVersion[]> {
         // Regular load workflow uses blobId === documentID to indicate "latest".
         if (blobid !== this.documentId && blobid) {
             // FluidFetch & FluidDebugger tools use empty sting to query for versions
@@ -230,14 +233,19 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
             const hostSnapshotOptions = this.hostPolicy.snapshotOptions;
             const odspSnapshotCacheValue: ISnapshotContents = await PerformanceEvent.timedExecAsync(
                 this.logger,
-                { eventName: "ObtainSnapshot" },
+                { eventName: "ObtainSnapshot", fetchSource },
                 async (event: PerformanceEvent) => {
                     const props: GetVersionsTelemetryProps = {};
                     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))
+
+                    let method: string;
+                    if (fetchSource === FetchSource.noCache) {
+                        retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+                        method = "networkOnly";
+                    } else {
+                        // 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(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.
@@ -264,46 +272,46 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
                                 return snapshotCachedEntry;
                             });
 
-                    // Based on the concurrentSnapshotFetch policy:
-                    // Either retrieve both the network and cache snapshots concurrently and pick the first to return,
-                    // or grab the cache value and then the network value if the cache value returns undefined.
-                    let method: string;
-                    if (this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
-                        const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions, scenarioName);
-
-                        // Ensure that failures on both paths are ignored initially.
-                        // I.e. if cache fails for some reason, we will proceed with network result.
-                        // And vice versa - if (for example) client is offline and network request fails first, we
-                        // do want to attempt to succeed with cached data!
-                        const promiseRaceWinner = await promiseRaceWithWinner([
-                            cachedSnapshotP.catch(() => undefined),
-                            networkSnapshotP.catch(() => undefined),
-                        ]);
-                        retrievedSnapshot = promiseRaceWinner.value;
-                        method = promiseRaceWinner.index === 0 ? "cache" : "network";
-
-                        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) {
-                                retrievedSnapshot = await cachedSnapshotP;
-                                method = "cache";
-                            }
+                        // 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.
+                        if (this.hostPolicy.concurrentSnapshotFetch && !this.hostPolicy.summarizerClient) {
+                            const networkSnapshotP = this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+
+                            // Ensure that failures on both paths are ignored initially.
+                            // I.e. if cache fails for some reason, we will proceed with network result.
+                            // And vice versa - if (for example) client is offline and network request fails first, we
+                            // do want to attempt to succeed with cached data!
+                            const promiseRaceWinner = await promiseRaceWithWinner([
+                                cachedSnapshotP.catch(() => undefined),
+                                networkSnapshotP.catch(() => undefined),
+                            ]);
+                            retrievedSnapshot = promiseRaceWinner.value;
+                            method = promiseRaceWinner.index === 0 ? "cache" : "network";
+
                             if (retrievedSnapshot === undefined) {
-                                retrievedSnapshot = await networkSnapshotP;
-                                method = "network";
+                                // 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) {
+                                    retrievedSnapshot = await cachedSnapshotP;
+                                    method = "cache";
+                                }
+                                if (retrievedSnapshot === undefined) {
+                                    retrievedSnapshot = await networkSnapshotP;
+                                    method = "network";
+                                }
                             }
-                        }
-                    } else {
-                        // 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.
+                        } else {
+                            // 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.
 
-                        retrievedSnapshot = await cachedSnapshotP;
+                            retrievedSnapshot = await cachedSnapshotP;
 
-                        method = retrievedSnapshot !== undefined ? "cache" : "network";
+                            method = retrievedSnapshot !== undefined ? "cache" : "network";
 
-                        if (retrievedSnapshot === undefined) {
-                            retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+                            if (retrievedSnapshot === undefined) {
+                                retrievedSnapshot = await this.fetchSnapshot(hostSnapshotOptions, scenarioName);
+                            }
                         }
                     }
                     if (method === "network") {

package/src/odspDriverUrlResolverForShareLink.ts

@@ -136,7 +136,7 @@ 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.shareLinkInfo = Object.assign(odspResolvedUrl.shareLinkInfo || {},
+            odspResolvedUrl.shareLinkInfo = Object.assign(odspResolvedUrl.shareLinkInfo ?? {},
                 { sharingLinkToRedeem: this.removeNavParam(request.url) });
         }
         if (odspResolvedUrl.itemId) {
@@ -171,10 +171,7 @@ export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
             return cachedLinkPromise;
         }
         const newLinkPromise = getFileLink(
-            this.shareLinkFetcherProps.tokenFetcher,
-            resolvedUrl,
-            this.shareLinkFetcherProps.identityType,
-            this.logger,
+            this.shareLinkFetcherProps.tokenFetcher, resolvedUrl, this.logger,
         ).catch((error) => {
             // This should imply that error is a non-retriable error.
             this.logger.sendErrorEvent({ eventName: "FluidFileUrlError" }, error);

package/src/odspLocationRedirection.ts

@@ -0,0 +1,23 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IFluidResolvedUrl } from "@fluidframework/driver-definitions";
+import { IOdspResolvedUrl } from "@fluidframework/odsp-driver-definitions";
+import { getOdspResolvedUrl } from "./odspUtils";
+
+/**
+ * It takes a resolved url with old siteUrl and creates a new resolved url with updated site url domain.
+ * @param resolvedUrl - Previous odsp resolved url with older site url.
+ * @param redirectLocation - Url at which the network call has to be made. It contains new site info.
+ * @returns - Resolved url after patching the correct siteUrl.
+ */
+export function patchOdspResolvedUrl(resolvedUrl: IFluidResolvedUrl, redirectLocation: string): IOdspResolvedUrl {
+    const odspResolvedUrl = { ...getOdspResolvedUrl(resolvedUrl) };
+    // Generate the new SiteUrl from the redirection location.
+    const newSiteDomain = new URL(redirectLocation).origin;
+    const newSiteUrl = `${newSiteDomain}${new URL(odspResolvedUrl.siteUrl).pathname}`;
+    odspResolvedUrl.siteUrl = newSiteUrl;
+    return odspResolvedUrl;
+}

package/src/odspSummaryUploadManager.ts

@@ -39,6 +39,7 @@ export class OdspSummaryUploadManager {
         logger: ITelemetryLogger,
         private readonly epochTracker: EpochTracker,
         private readonly forceAccessTokenViaAuthorizationHeader: boolean,
+        private readonly relayServiceTenantAndSessionId: () => string,
     ) {
         this.mc = loggerToMonitoringContext(logger);
     }
@@ -93,9 +94,8 @@ export class OdspSummaryUploadManager {
                 this.forceAccessTokenViaAuthorizationHeader,
             );
             headers["Content-Type"] = "application/json";
-            if (parentHandle) {
-                headers["If-Match"] = `fluid:containerid=${parentHandle}`;
-            }
+            headers["If-Match"] = `fluid:sessionid=${
+                this.relayServiceTenantAndSessionId()}${parentHandle ? `;containerid=${parentHandle}` : ""}`;
 
             const postBody = JSON.stringify(snapshot);
 

package/src/odspUrlHelper.ts

@@ -69,7 +69,7 @@ export function isOdcUrl(url: string | URL): boolean {
     // Format: /v2.1/drives('ABC123')/items('ABC123!123')
     const odcODataRegex = /\/v2.1\/drives\('[^/]+'\)\/items\('[\da-z]+!\d+'\)/;
 
-    return !!(odcRegex.exec(path) || odcODataRegex.exec(path));
+    return !!(odcRegex.exec(path) ?? odcODataRegex.exec(path));
 }
 
 /**

package/src/odspUtils.ts

@@ -13,7 +13,7 @@ import {
     NetworkErrorBasic,
 } from "@fluidframework/driver-utils";
 import { assert, performance } from "@fluidframework/common-utils";
-import { ChildLogger, PerformanceEvent, wrapError } from "@fluidframework/telemetry-utils";
+import { ChildLogger, PerformanceEvent, TelemetryDataTag, wrapError } from "@fluidframework/telemetry-utils";
 import {
     fetchIncorrectResponse,
     throwOdspNetworkError,
@@ -123,7 +123,8 @@ export async function fetchHelper(
     }, (error) => {
         const online = isOnline();
         const errorText = `${error}`;
-
+        const urlRegex = /((http|https):\/\/(\S*))/i;
+        const redactedErrorText = errorText.replace(urlRegex, "REDACTED_URL");
         // This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
         if (error.name === "AbortError") {
             throw new RetryableError(
@@ -143,13 +144,23 @@ export async function fetchHelper(
         if (online === OnlineStatus.Offline) {
             throw new RetryableError(
                 // pre-0.58 error message prefix: Offline
-                `ODSP fetch failure (Offline): ${errorText}`, DriverErrorType.offlineError, { driverVersion });
+                `ODSP fetch failure (Offline): ${redactedErrorText}`,
+                DriverErrorType.offlineError,
+                {
+                    driverVersion,
+                    rawErrorMessage: { value: errorText, tag: TelemetryDataTag.UserData },
+                });
         } else {
             // It is perhaps still possible that this is due to being offline, the error does not reveal enough
             // information to conclude.  Could also be DNS errors, malformed fetch request, CSP violation, etc.
             throw new RetryableError(
                 // pre-0.58 error message prefix: Fetch error
-                `ODSP fetch failure: ${errorText}`, DriverErrorType.fetchFailure, { driverVersion });
+                `ODSP fetch failure: ${redactedErrorText}`,
+                DriverErrorType.fetchFailure,
+                {
+                    driverVersion,
+                    rawErrorMessage: { value: errorText, tag: TelemetryDataTag.UserData },
+                });
         }
     });
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "1.2.1";
+export const pkgVersion = "2.0.0-internal.1.0.0";

package/src/retryUtils.ts

@@ -5,7 +5,7 @@
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { delay, performance } from "@fluidframework/common-utils";
-import { canRetryOnError } from "@fluidframework/driver-utils";
+import { canRetryOnError, getRetryDelayFromError } from "@fluidframework/driver-utils";
 import { OdspErrorType } from "@fluidframework/odsp-driver-definitions";
 import { Odsp409Error } from "./epochTracker";
 
@@ -43,8 +43,10 @@ export async function runWithRetry<T>(
 
             const coherencyError = error?.[Odsp409Error] === true;
             const serviceReadonlyError = error?.errorType === OdspErrorType.serviceReadOnly;
-            // Retry for retriable 409 coherency errors or serviceReadOnly errors.
-            if (!(coherencyError || serviceReadonlyError || canRetry)) {
+            // Retry for retriable 409 coherency errors or serviceReadOnly errors. These errors are always retriable
+            // unless someone specifically set canRetry = false on the error like in fetchSnapshot() flow. So in
+            // that case don't retry.
+            if (!((coherencyError || serviceReadonlyError) && canRetry)) {
                 throw error;
             }
 
@@ -54,8 +56,8 @@ export async function runWithRetry<T>(
             if (attempts === 5) {
                 logger.sendErrorEvent(
                     {
-                        eventName: coherencyError ?
-                            "CoherencyErrorTooManyRetries" : "ServiceReadonlyErrorTooManyRetries",
+                        eventName: coherencyError ? "CoherencyErrorTooManyRetries" :
+                            "ServiceReadonlyErrorTooManyRetries",
                         callName,
                         attempts,
                         duration: performance.now() - start, // record total wait time.
@@ -66,6 +68,7 @@ export async function runWithRetry<T>(
                 throw error;
             }
 
+            retryAfter = getRetryDelayFromError(error) ?? retryAfter;
             await delay(Math.floor(retryAfter));
             retryAfter += retryAfter / 4 * (1 + Math.random());
             lastError = error;