@fluidframework/odsp-driver 1.0.1 → 1.1.0

package/src/odspDocumentDeltaConnection.ts

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

package/src/odspDocumentService.ts

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

package/src/odspDocumentStorageManager.ts

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

package/src/odspError.ts

@@ -4,20 +4,33 @@
  */
 
 import { createOdspNetworkError } from "@fluidframework/odsp-doclib-utils";
+import { DriverErrorType } from "@fluidframework/driver-definitions";
+import { NonRetryableError } from "@fluidframework/driver-utils";
+import { OdspError } from "@fluidframework/odsp-driver-definitions";
+import { IFluidErrorBase } from "@fluidframework/telemetry-utils";
 import { IOdspSocketError } from "./contracts";
+import { pkgVersion as driverVersion } from "./packageVersion";
 
 /**
  * Returns network error based on error object from ODSP socket (IOdspSocketError)
  */
-export function errorObjectFromSocketError(socketError: IOdspSocketError, handler: string) {
-    // pre-0.58 error message prefix: OdspSocketError
-    const message = `ODSP socket error (${handler}): ${socketError.message}`;
-    const error = createOdspNetworkError(
-        message,
-        socketError.code,
-        socketError.retryAfter);
+export function errorObjectFromSocketError(socketError: IOdspSocketError, handler: string):
+    IFluidErrorBase & OdspError {
+    // Make sure we always return something, and do not throw.
+    try {
+        // pre-0.58 error message prefix: OdspSocketError
+        const message = `ODSP socket error (${handler}): ${socketError.message}`;
+        const error = createOdspNetworkError(
+            message,
+            socketError.code,
+            socketError.retryAfter);
 
-    error.addTelemetryProperties({ odspError: true, relayServiceError: true });
-
-    return error;
+        error.addTelemetryProperties({ odspError: true, relayServiceError: true });
+        return error;
+    } catch (error) {
+        return new NonRetryableError(
+            "Internal error: errorObjectFromSocketError",
+            DriverErrorType.fileNotFoundOrAccessDeniedError,
+            { driverVersion });
+    }
 }

package/src/odspPublicUtils.ts

@@ -4,8 +4,25 @@
  */
 
 import { hashFile, IsoBuffer } from "@fluidframework/common-utils";
+import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 
 export async function getHashedDocumentId(driveId: string, itemId: string): Promise<string> {
     const buffer = IsoBuffer.from(`${driveId}_${itemId}`);
     return encodeURIComponent(await hashFile(buffer, "SHA-256", "base64"));
 }
+
+export interface ISnapshotContents {
+    snapshotTree: ISnapshotTree;
+    blobs: Map<string, ArrayBuffer>;
+    ops: ISequencedDocumentMessage[];
+
+    /**
+     * Sequence number of the snapshot
+     */
+    sequenceNumber: number | undefined;
+
+    /**
+     * Sequence number for the latest op/snapshot for the file in ODSP
+     */
+    latestSequenceNumber: number | undefined;
+}

package/src/odspSnapshotParser.ts

@@ -6,7 +6,7 @@
 import { assert, stringToBuffer } from "@fluidframework/common-utils";
 import * as api from "@fluidframework/protocol-definitions";
 import { IOdspSnapshot, IOdspSnapshotCommit, ISnapshotTreeEx } from "./contracts";
-import { ISnapshotContents } from "./odspUtils";
+import { ISnapshotContents } from "./odspPublicUtils";
 
 /**
  * Build a tree hierarchy base on a flat tree
@@ -51,7 +51,7 @@ function buildHierarchy(flatTree: IOdspSnapshotCommit): api.ISnapshotTree {
  * Converts existing IOdspSnapshot to snapshot tree, blob array and ops
  * @param odspSnapshot - snapshot
  */
-export function convertOdspSnapshotToSnapsohtTreeAndBlobs(
+export function convertOdspSnapshotToSnapshotTreeAndBlobs(
     odspSnapshot: IOdspSnapshot,
 ): ISnapshotContents {
     const blobsWithBufferContent = new Map<string, ArrayBuffer>();
@@ -62,11 +62,16 @@ export function convertOdspSnapshotToSnapsohtTreeAndBlobs(
             blobsWithBufferContent.set(blob.id, stringToBuffer(blob.content, blob.encoding ?? "utf8"));
         });
     }
+
+    const sequenceNumber = odspSnapshot?.trees[0].sequenceNumber;
+
     const val: ISnapshotContents = {
         blobs: blobsWithBufferContent,
         ops: odspSnapshot.ops?.map((op) => op.op) ?? [],
-        sequenceNumber: odspSnapshot?.trees[0].sequenceNumber,
+        sequenceNumber,
         snapshotTree: buildHierarchy(odspSnapshot.trees[0]),
+        latestSequenceNumber: (odspSnapshot.ops && odspSnapshot.ops.length > 0) ?
+            odspSnapshot.ops[odspSnapshot.ops.length - 1].sequenceNumber : sequenceNumber,
     };
     return val;
 }

package/src/odspUtils.ts

@@ -13,7 +13,6 @@ import {
     NetworkErrorBasic,
 } 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,
@@ -43,13 +42,6 @@ export const getWithRetryForTokenRefreshRepeat = "getWithRetryForTokenRefreshRep
 /** Parse the given url and return the origin (host name) */
 export const getOrigin = (url: string) => new URL(url).origin;
 
-export interface ISnapshotContents {
-    snapshotTree: ISnapshotTree;
-    blobs: Map<string, ArrayBuffer>;
-    ops: ISequencedDocumentMessage[];
-    sequenceNumber: number | undefined;
-}
-
 export interface IOdspResponse<T> {
     content: T;
     headers: Map<string, string>;
@@ -243,7 +235,8 @@ export const createOdspLogger = (logger?: ITelemetryBaseLogger) =>
     ChildLogger.create(
         logger,
         "OdspDriver",
-        { all:
+        {
+            all:
             {
                 driverVersion,
             },
@@ -307,7 +300,7 @@ export function toInstrumentedOdspTokenFetcher(
                 if (token === null && throwOnNullToken) {
                     throw new NonRetryableError(
                         // pre-0.58 error message: Token is null for ${name} call
-                        `The Host-provided token fetcher for ${name} call returned null`,
+                        `The Host-provided token fetcher returned null`,
                         OdspErrorType.fetchTokenError,
                         { method: name, driverVersion });
                 }
@@ -319,7 +312,7 @@ export function toInstrumentedOdspTokenFetcher(
                 const tokenError = wrapError(
                     error,
                     (errorMessage) => new NetworkErrorBasic(
-                        `The Host-provided token fetcher for ${name} call threw an error: ${errorMessage}`,
+                        `The Host-provided token fetcher threw an error: ${errorMessage}`,
                         OdspErrorType.fetchTokenError,
                         typeof rawCanRetry === "boolean" ? rawCanRetry : false /* canRetry */,
                         { method: name, driverVersion }));

package/src/packageVersion.ts

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