@fluidframework/routerlicious-driver 2.0.0-dev.1.4.5.105745 → 2.0.0-dev.2.2.0.111723

package/src/deltaStorageService.ts

@@ -11,9 +11,8 @@ import {
 } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { readAndParse, requestOps, emptyMessageStream } from "@fluidframework/driver-utils";
-import { TelemetryNullLogger } from "@fluidframework/common-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { PerformanceEvent, TelemetryNullLogger } from "@fluidframework/telemetry-utils";
 import { RestWrapper } from "@fluidframework/server-services-client";
 import { DocumentStorageService } from "./documentStorageService";
 
@@ -27,7 +26,8 @@ export class DocumentDeltaStorageService implements IDocumentDeltaStorageService
         private readonly tenantId: string,
         private readonly id: string,
         private readonly deltaStorageService: IDeltaStorageService,
-        private readonly documentStorageService: DocumentStorageService) {
+        private readonly documentStorageService: DocumentStorageService,
+        private readonly logger: ITelemetryLogger) {
     }
 
     private logtailSha: string | undefined = this.documentStorageService.logTailSha;
@@ -62,11 +62,20 @@ export class DocumentDeltaStorageService implements IDocumentDeltaStorageService
 
         this.logtailSha = undefined;
         if (opsFromLogTail.length > 0) {
-            const messages = opsFromLogTail.filter((op) =>
-                op.sequenceNumber >= from,
-            );
-            if (messages.length > 0) {
-                return { messages, partialResult: true };
+            try {
+                const messages = opsFromLogTail.filter((op, i) => {
+                    // throw if the sequence numbers in logtail are not contiguous
+                    if (i > 0 && op.sequenceNumber !== opsFromLogTail[i - 1].sequenceNumber + 1) {
+                        throw new Error("Log tail ops are not contiguous");
+                    }
+                    return op.sequenceNumber >= from;
+                });
+                
+                if (messages.length > 0 && messages[0].sequenceNumber === from) {
+                    return { messages, partialResult: true };
+                }     
+            } catch (error) {
+                this.logger.sendErrorEvent({ eventName: "LogTailReadError" }, error);
             }
         }
 

package/src/documentDeltaConnection.ts

@@ -5,8 +5,7 @@
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { DocumentDeltaConnection } from "@fluidframework/driver-base";
-import { IDocumentDeltaConnection } from "@fluidframework/driver-definitions";
-import { IAnyDriverError } from "@fluidframework/driver-utils";
+import { IAnyDriverError, IDocumentDeltaConnection } from "@fluidframework/driver-definitions";
 import { IClient, IConnect } from "@fluidframework/protocol-definitions";
 import type { io as SocketIOClientStatic } from "socket.io-client";
 import { errorObjectFromSocketError, IR11sSocketError } from "./errorUtils";

package/src/documentService.ts

@@ -33,6 +33,7 @@ const RediscoverAfterTimeSinceDiscoveryMs = 5 * 60000; // 5 minute
  * The DocumentService manages the Socket.IO connection and manages routing requests to connected
  * clients.
  */
+// eslint-disable-next-line import/namespace
 export class DocumentService implements api.IDocumentService {
     private lastDiscoveredAt: number = Date.now();
     private discoverP: Promise<void> | undefined;
@@ -175,6 +176,7 @@ export class DocumentService implements api.IDocumentService {
             this.documentId,
             deltaStorageService,
             this.documentStorageService,
+            this.logger,
         );
     }
 
@@ -188,20 +190,42 @@ export class DocumentService implements api.IDocumentService {
             if (this.shouldUpdateDiscoveredSessionInfo()) {
                 await this.refreshDiscovery();
             }
-            const ordererToken = await this.tokenProvider.fetchOrdererToken(
-                this.tenantId,
-                this.documentId,
-                refreshToken,
+
+            const ordererToken = await PerformanceEvent.timedExecAsync(
+                this.logger,
+                {
+                    eventName: "GetDeltaStreamToken",
+                    docId: this.documentId,
+                    details: JSON.stringify({
+                        refreshToken,
+                    }),
+                },
+                async () => {
+                    return this.tokenProvider.fetchOrdererToken(
+                        this.tenantId,
+                        this.documentId,
+                        refreshToken,
+                    );
+                }
             );
 
-            return R11sDocumentDeltaConnection.create(
-                this.tenantId,
-                this.documentId,
-                ordererToken.jwt,
-                io,
-                client,
-                this.deltaStreamUrl,
+            return PerformanceEvent.timedExecAsync(
                 this.logger,
+                {
+                    eventName: "ConnectToDeltaStream",
+                    docId: this.documentId,
+                },
+                async () => {
+                    return R11sDocumentDeltaConnection.create(
+                        this.tenantId,
+                        this.documentId,
+                        ordererToken.jwt,
+                        io,
+                        client,
+                        this.deltaStreamUrl,
+                        this.logger,
+                    );
+                }
             );
         };
 
@@ -228,7 +252,7 @@ export class DocumentService implements api.IDocumentService {
             this.discoverP = PerformanceEvent.timedExecAsync(
                 this.logger,
                 {
-                    eventName: "refreshSessionDiscovery",
+                    eventName: "RefreshDiscovery",
                 },
                 async () => this.refreshDiscoveryCore(),
             );
@@ -243,7 +267,6 @@ export class DocumentService implements api.IDocumentService {
         this.ordererUrl = fluidResolvedUrl.endpoints.ordererUrl;
         this.deltaStorageUrl = fluidResolvedUrl.endpoints.deltaStorageUrl;
         this.deltaStreamUrl = fluidResolvedUrl.endpoints.deltaStreamUrl || this.ordererUrl;
-        this.lastDiscoveredAt = Date.now();
     }
 
     /**
@@ -259,6 +282,15 @@ export class DocumentService implements api.IDocumentService {
         // Disconnect event is not so reliable in local testing. To ensure re-discovery when necessary,
         // re-discover if enough time has passed since last discovery.
         const pastLastDiscoveryTimeThreshold = (now - this.lastDiscoveredAt) > RediscoverAfterTimeSinceDiscoveryMs;
+        if (pastLastDiscoveryTimeThreshold) {
+            // Reset discover promise and refresh discovery.
+            this.lastDiscoveredAt = Date.now();
+            this.discoverP = undefined;
+            this.refreshDiscovery().catch(() => {
+                // Undo discovery time set on failure, so that next check refreshes.
+                this.lastDiscoveredAt = 0;
+            });
+        }
         return pastLastDiscoveryTimeThreshold;
     }
 }

package/src/documentServiceFactory.ts

@@ -18,7 +18,7 @@ import {
     getQuorumValuesFromProtocolSummary,
     RateLimiter,
 } from "@fluidframework/driver-utils";
-import { ChildLogger } from "@fluidframework/telemetry-utils";
+import { ChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { ISession } from "@fluidframework/server-services-client";
 import { DocumentService } from "./documentService";
 import { IRouterliciousDriverPolicies } from "./policies";
@@ -108,16 +108,34 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
             resolvedUrl.endpoints.ordererUrl,
         );
 
-        // @TODO: Remove returned "string" type when removing back-compat code
-        const res = await ordererRestWrapper.post<{ id: string; token?: string; session?: ISession; } | string>(
-            `/documents/${tenantId}`,
+        const res = await PerformanceEvent.timedExecAsync(
+            logger2,
             {
-                summary: convertSummaryToCreateNewSummary(appSummary),
-                sequenceNumber: documentAttributes.sequenceNumber,
-                values: quorumValues,
-                enableDiscovery: this.driverPolicies.enableDiscovery,
-                generateToken: this.tokenProvider.documentPostCreateCallback !== undefined,
+                eventName: "CreateNew",
+                details: JSON.stringify({
+                    enableDiscovery: this.driverPolicies.enableDiscovery,
+                    sequenceNumber: documentAttributes.sequenceNumber,
+                }),
             },
+            async (event) => {
+                // @TODO: Remove returned "string" type when removing back-compat code
+                const postRes = await ordererRestWrapper.post<
+                    { id: string; token?: string; session?: ISession; } | string
+                >(`/documents/${tenantId}`, {
+                    summary: convertSummaryToCreateNewSummary(appSummary),
+                    sequenceNumber: documentAttributes.sequenceNumber,
+                    values: quorumValues,
+                    enableDiscovery: this.driverPolicies.enableDiscovery,
+                    generateToken:
+                        this.tokenProvider.documentPostCreateCallback !==
+                        undefined,
+                });
+
+                event.end({
+                    docId: typeof postRes === "string" ? postRes : postRes.id,
+                });
+                return postRes;
+            }
         );
 
         // For supporting backward compatibility, when the request has generateToken === true, it will return
@@ -138,12 +156,20 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
 
         // @TODO: Remove token from the condition, checking the documentPostCreateCallback !== undefined
         // is sufficient to determine if the token will be undefined or not.
-        if (token && this.tokenProvider.documentPostCreateCallback !== undefined) {
-            try {
-                await this.tokenProvider.documentPostCreateCallback(documentId, token);
-            } catch (error: any) {
-                throw new DocumentPostCreateError(error);
-            }
+        try {
+            await PerformanceEvent.timedExecAsync(
+                logger2,
+                {
+                    eventName: "DocPostCreateCallback",
+                    docId: documentId,
+                },
+                async () => {
+                    if (token && this.tokenProvider.documentPostCreateCallback !== undefined) {
+                        return this.tokenProvider.documentPostCreateCallback(documentId, token);
+                    }
+                });
+        } catch (error: any) {
+            throw new DocumentPostCreateError(error);
         }
 
         parsedUrl.set("pathname", replaceDocumentIdInPath(parsedUrl.pathname, documentId));
@@ -206,10 +232,18 @@ export class RouterliciousDocumentServiceFactory implements IDocumentServiceFact
                 this.driverPolicies.enableRestLess,
                 resolvedUrl.endpoints.ordererUrl,
             );
-            // The service responds with the current document session associated with the container.
-            const discoveredSession = await ordererRestWrapper.get<ISession>(
-                `/documents/${tenantId}/session/${documentId}`,
-            );
+
+            const discoveredSession = await PerformanceEvent.timedExecAsync(
+                logger2,
+                {
+                    eventName: "DiscoverSession",
+                    docId: documentId,
+                },
+                async () => {
+                    // The service responds with the current document session associated with the container.
+                    return ordererRestWrapper.get<ISession>(
+                        `/documents/${tenantId}/session/${documentId}`);
+                });
             return getDiscoveredFluidResolvedUrl(resolvedUrl, discoveredSession);
         };
         const fluidResolvedUrl: IFluidResolvedUrl = session !== undefined

package/src/index.ts

@@ -3,11 +3,12 @@
  * Licensed under the MIT License.
  */
 
-export * from "./defaultTokenProvider";
-export * from "./deltaStorageService";
-export * from "./documentService";
-export * from "./documentServiceFactory";
-export * from "./documentStorageService";
-export * from "./nullBlobStorageService";
-export * from "./policies";
-export * from "./tokens";
+// Tokens
+export { DefaultTokenProvider } from "./defaultTokenProvider";
+export { ITokenProvider, ITokenResponse, ITokenService } from "./tokens";
+
+// Factory
+export { DocumentPostCreateError, RouterliciousDocumentServiceFactory } from "./documentServiceFactory";
+
+// Configuration
+export { IRouterliciousDriverPolicies } from "./policies";

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "2.0.0-dev.1.4.5.105745";
+export const pkgVersion = "2.0.0-dev.2.2.0.111723";

package/src/restWrapper.ts

@@ -11,6 +11,7 @@ import {
     RestLessClient,
     RestWrapper,
 } from "@fluidframework/server-services-client";
+import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import fetch from "cross-fetch";
 import type { AxiosRequestConfig, AxiosRequestHeaders } from "axios";
 import safeStringify from "json-stringify-safe";
@@ -145,17 +146,26 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
             token: `${fromUtf8ToBase64(tenantId)}`,
         };
         const getAuthorizationHeader: AuthorizationHeaderGetter = async (refreshToken?: boolean): Promise<string> => {
-            // Craft credentials using tenant id and token
-            const storageToken = await tokenProvider.fetchStorageToken(
-                tenantId,
-                documentId,
-                refreshToken,
+            return PerformanceEvent.timedExecAsync(
+                logger,
+                {
+                    eventName: "FetchStorageToken",
+                    docId: documentId,
+                },
+                async () => {
+                    // Craft credentials using tenant id and token
+                    const storageToken = await tokenProvider.fetchStorageToken(
+                        tenantId,
+                        documentId,
+                        refreshToken
+                    );
+                    const credentials = {
+                        password: storageToken.jwt,
+                        user: tenantId,
+                    };
+                    return getAuthorizationTokenFromCredentials(credentials);
+                }
             );
-            const credentials = {
-                password: storageToken.jwt,
-                user: tenantId,
-            };
-            return getAuthorizationTokenFromCredentials(credentials);
         };
 
         const restWrapper = new RouterliciousStorageRestWrapper(
@@ -194,12 +204,21 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
         baseurl?: string,
     ): Promise<RouterliciousOrdererRestWrapper> {
         const getAuthorizationHeader: AuthorizationHeaderGetter = async (refreshToken?: boolean): Promise<string> => {
-            const ordererToken = await tokenProvider.fetchOrdererToken(
-                tenantId,
-                documentId,
-                refreshToken,
+            return PerformanceEvent.timedExecAsync(
+                logger,
+                {
+                    eventName: "FetchOrdererToken",
+                    docId: documentId,
+                },
+                async () => {
+                    const ordererToken = await tokenProvider.fetchOrdererToken(
+                        tenantId,
+                        documentId,
+                        refreshToken,
+                    );
+                    return `Basic ${ordererToken.jwt}`;
+                }
             );
-            return `Basic ${ordererToken.jwt}`;
         };
 
         const restWrapper = new RouterliciousOrdererRestWrapper(

package/src/urlUtils.ts

@@ -21,30 +21,26 @@ export const replaceDocumentIdInPath = (urlPath: string, documentId: string): st
     urlPath.split("/").slice(0, -1).concat([documentId]).join("/");
 
 export const getDiscoveredFluidResolvedUrl = (resolvedUrl: IFluidResolvedUrl, session: ISession): IFluidResolvedUrl => {
-    if (session) {
-        const discoveredOrdererUrl = new URLParse(session.ordererUrl);
-        const deltaStorageUrl = new URLParse(resolvedUrl.endpoints.deltaStorageUrl);
-        deltaStorageUrl.set("host", discoveredOrdererUrl.host);
+    const discoveredOrdererUrl = new URLParse(session.ordererUrl);
+    const deltaStorageUrl = new URLParse(resolvedUrl.endpoints.deltaStorageUrl);
+    deltaStorageUrl.set("host", discoveredOrdererUrl.host);
 
-        const discoveredStorageUrl = new URLParse(session.historianUrl);
-        const storageUrl = new URLParse(resolvedUrl.endpoints.storageUrl);
-        storageUrl.set("host", discoveredStorageUrl.host);
+    const discoveredStorageUrl = new URLParse(session.historianUrl);
+    const storageUrl = new URLParse(resolvedUrl.endpoints.storageUrl);
+    storageUrl.set("host", discoveredStorageUrl.host);
 
-        const parsedUrl = parseFluidUrl(resolvedUrl.url);
-        const discoveredResolvedUrl: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl: deltaStorageUrl.toString(),
-                ordererUrl: session.ordererUrl,
-                storageUrl: storageUrl.toString(),
-            },
-            id: resolvedUrl.id,
-            tokens: resolvedUrl.tokens,
-            type: resolvedUrl.type,
-            url: new URLParse(`fluid://${discoveredOrdererUrl.host}${parsedUrl.pathname}`).toString(),
-        };
-
-        return discoveredResolvedUrl;
-    } else {
-        return resolvedUrl;
-    }
+    const parsedUrl = parseFluidUrl(resolvedUrl.url);
+    const discoveredResolvedUrl: IFluidResolvedUrl = {
+        endpoints: {
+            deltaStorageUrl: deltaStorageUrl.toString(),
+            ordererUrl: session.ordererUrl,
+            deltaStreamUrl: session.deltaStreamUrl,
+            storageUrl: storageUrl.toString(),
+        },
+        id: resolvedUrl.id,
+        tokens: resolvedUrl.tokens,
+        type: resolvedUrl.type,
+        url: new URLParse(`fluid://${discoveredOrdererUrl.host}${parsedUrl.pathname}`).toString(),
+    };
+    return discoveredResolvedUrl;
 };