@fluidframework/odsp-driver 0.56.0 → 0.57.0-51086

package/src/odspSummaryUploadManager.ts

@@ -46,7 +46,9 @@ export class OdspSummaryUploadManager {
     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) {
+        // Don't bother logging if lastSummaryProposalHandle hasn't been set before; only log on a positive mismatch.
+        if (this.lastSummaryProposalHandle !== undefined &&
+            this.lastSummaryProposalHandle !== context.proposalHandle) {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "LastSummaryProposedHandleMismatch",
                 ackedSummaryProposedHandle: context.proposalHandle,
@@ -106,6 +108,7 @@ export class OdspSummaryUploadManager {
                     headers: Object.keys(headers).length !== 0 ? true : undefined,
                     blobs,
                     size: postBody.length,
+                    referenceSequenceNumber,
                 },
                 async () => {
                     const response = await this.epochTracker.fetchAndParseAsJSON<IWriteSummaryResponse>(

package/src/odspUtils.ts

@@ -5,7 +5,13 @@
 
 import { ITelemetryProperties, ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { IResolvedUrl, DriverErrorType } from "@fluidframework/driver-definitions";
-import { isOnline, OnlineStatus, RetryableError, NonRetryableError } from "@fluidframework/driver-utils";
+import {
+    isOnline,
+    OnlineStatus,
+    RetryableError,
+    NonRetryableError,
+    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";
@@ -28,7 +34,7 @@ import {
     InstrumentedStorageTokenFetcher,
 } from "@fluidframework/odsp-driver-definitions";
 import { fetch } from "./fetch";
-import { pkgVersion } from "./packageVersion";
+import { pkgVersion as driverVersion } from "./packageVersion";
 import { IOdspSnapshot } from "./contracts";
 
 export const getWithRetryForTokenRefreshRepeat = "getWithRetryForTokenRefreshRepeat";
@@ -46,7 +52,7 @@ export interface ISnapshotContents {
 export interface IOdspResponse<T> {
     content: T;
     headers: Map<string, string>;
-    commonSpoHeaders: ITelemetryProperties;
+    propsToLog: ITelemetryProperties;
     duration: number,
 }
 
@@ -105,7 +111,8 @@ export async function fetchHelper(
             throw new NonRetryableError(
                 "odspFetchErrorNoResponse",
                 "No response from fetch call",
-                DriverErrorType.incorrectServerResponse);
+                DriverErrorType.incorrectServerResponse,
+                { driverVersion });
         }
         if (!response.ok || response.status < 200 || response.status >= 300) {
             throwOdspNetworkError(
@@ -116,7 +123,7 @@ export async function fetchHelper(
         return {
             content: response,
             headers,
-            commonSpoHeaders: getSPOAndGraphRequestIdsFromResponse(headers),
+            propsToLog: getSPOAndGraphRequestIdsFromResponse(headers),
             duration: performance.now() - start,
         };
     }, (error) => {
@@ -130,11 +137,13 @@ export async function fetchHelper(
         }
         // This error is thrown by fetch() when AbortSignal is provided and it gets cancelled
         if (error.name === "AbortError") {
-            throw new RetryableError("fetchAbort", "Fetch Timeout (AbortError)", OdspErrorType.fetchTimeout);
+            throw new RetryableError(
+                "fetchAbort", "Fetch Timeout (AbortError)", OdspErrorType.fetchTimeout, { driverVersion });
         }
         // TCP/IP timeout
         if (errorText.indexOf("ETIMEDOUT") !== -1) {
-            throw new RetryableError("fetchETimedout", "Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout);
+            throw new RetryableError(
+                "fetchETimedout", "Fetch Timeout (ETIMEDOUT)", OdspErrorType.fetchTimeout, { driverVersion });
         }
 
         //
@@ -143,9 +152,11 @@ export async function fetchHelper(
         // It is also non-serializable object due to circular references.
         //
         if (online === OnlineStatus.Offline) {
-            throw new RetryableError("OdspFetchOffline", `Offline: ${errorText}`, DriverErrorType.offlineError);
+            throw new RetryableError(
+                "OdspFetchOffline", `Offline: ${errorText}`, DriverErrorType.offlineError, { driverVersion });
         } else {
-            throw new RetryableError("OdspFetchError", `Fetch error: ${errorText}`, DriverErrorType.fetchFailure);
+            throw new RetryableError(
+                "OdspFetchError", `Fetch error: ${errorText}`, DriverErrorType.fetchFailure, { driverVersion });
         }
     });
 }
@@ -159,14 +170,14 @@ export async function fetchArray(
     requestInfo: RequestInfo,
     requestInit: RequestInit | undefined,
 ): Promise<IOdspResponse<ArrayBuffer>> {
-    const { content, headers, commonSpoHeaders, duration } = await fetchHelper(requestInfo, requestInit);
+    const { content, headers, propsToLog, duration } = await fetchHelper(requestInfo, requestInit);
 
     const arrayBuffer = await content.arrayBuffer();
-    commonSpoHeaders.bodySize = arrayBuffer.byteLength;
+    propsToLog.bodySize = arrayBuffer.byteLength;
     return {
         headers,
         content: arrayBuffer,
-        commonSpoHeaders,
+        propsToLog,
         duration,
     };
 }
@@ -180,7 +191,7 @@ export async function fetchAndParseAsJSONHelper<T>(
     requestInfo: RequestInfo,
     requestInit: RequestInit | undefined,
 ): Promise<IOdspResponse<T>> {
-    const { content, headers, commonSpoHeaders, duration } = await fetchHelper(requestInfo, requestInit);
+    const { content, headers, propsToLog, duration } = await fetchHelper(requestInfo, requestInit);
     let text: string | undefined;
     try {
         text = await content.text();
@@ -198,11 +209,11 @@ export async function fetchAndParseAsJSONHelper<T>(
         );
     }
 
-    commonSpoHeaders.bodySize = text.length;
+    propsToLog.bodySize = text.length;
     const res = {
         headers,
         content: JSON.parse(text),
-        commonSpoHeaders,
+        propsToLog,
         duration,
     };
     return res;
@@ -232,7 +243,7 @@ export const createOdspLogger = (logger?: ITelemetryBaseLogger) =>
         "OdspDriver",
         { all :
             {
-                driverVersion: pkgVersion,
+                driverVersion,
             },
         });
 
@@ -298,17 +309,21 @@ export function toInstrumentedOdspTokenFetcher(
                         "storageTokenIsNull",
                         `Token is null for ${name} call`,
                         OdspErrorType.fetchTokenError,
-                        { method: name });
+                        { method: name, driverVersion });
                 }
                 return token;
             }, (error) => {
+                // There is an important but unofficial contract here where token providers can set canRetry: true
+                // to hook into the driver's retry logic (e.g. the retry loop when initiating a connection)
+                const rawCanRetry = error?.canRetry;
                 const tokenError = wrapError(
                     error,
-                    (errorMessage) => new NonRetryableError(
+                    (errorMessage) => new NetworkErrorBasic(
                         "tokenFetcherFailed",
                         errorMessage,
                         OdspErrorType.fetchTokenError,
-                        { method: name }));
+                        typeof rawCanRetry === "boolean" ? rawCanRetry : false /* canRetry */,
+                        { method: name, driverVersion }));
                 throw tokenError;
             }),
             { cancel: "generic" });

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "0.56.0";
+export const pkgVersion = "0.57.0-51086";

package/src/retryUtils.ts

@@ -68,7 +68,7 @@ export async function runWithRetry<T>(
 
             assert(canRetry, 0x24d /* "can retry" */);
             await delay(Math.floor(retryAfter));
-            retryAfter += retryAfter / 4  * (1 + Math.random());
+            retryAfter += retryAfter / 4 * (1 + Math.random());
             lastError = error;
         }
     }

package/src/vroom.ts

@@ -94,7 +94,7 @@ export async function fetchJoinSession(
 
             // TODO SPO-specific telemetry
             event.end({
-                ...response.commonSpoHeaders,
+                ...response.propsToLog,
                 // pushV2 websocket urls will contain pushf
                 pushv2: socketUrl.includes("pushf"),
                 webSocketHostName,

package/src/zipItDataRepresentationUtils.ts

@@ -12,6 +12,7 @@ import { assert, IsoBuffer, Uint8ArrayToArrayBuffer, Uint8ArrayToString } from "
 import { NonRetryableError } from "@fluidframework/driver-utils";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { ReadBuffer } from "./ReadBufferUtils";
+import { pkgVersion as driverVersion } from "./packageVersion";
 
 // eslint-disable-next-line max-len
 // https://onedrive.visualstudio.com/SharePoint%20Online/_git/SPO?path=/cobalt/Base/Property/BinaryEncodedPropertyReader.cs&version=GBmaster&_a=contents
@@ -485,6 +486,7 @@ function throwBufferParseException(
         {
             nodeType: getNodeType(node),
             expectedNodeType,
+            driverVersion,
         });
 }