@fluidframework/routerlicious-driver 2.5.0-302463 → 2.5.0

package/src/errorUtils.ts

@@ -13,9 +13,11 @@ import {
 	GenericNetworkError,
 	NonRetryableError,
 	createGenericNetworkError,
+	type DriverErrorTelemetryProps,
 } from "@fluidframework/driver-utils/internal";
-import { IFluidErrorBase } from "@fluidframework/telemetry-utils/internal";
+import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils/internal";
 
+import { R11sServiceClusterDrainingErrorCode } from "./contracts.js";
 import { pkgVersion as driverVersion } from "./packageVersion.js";
 
 /**
@@ -31,6 +33,12 @@ export const RouterliciousErrorTypes = {
 	 * SSL Certificate Error.
 	 */
 	sslCertError: "sslCertError",
+
+	/**
+	 * Error for when the service drains a cluster to which the socket connection is connected to and it disconnects
+	 * all the clients in that cluster.
+	 */
+	clusterDrainingError: "clusterDrainingError",
 } as const;
 /**
  * @internal
@@ -66,6 +74,24 @@ export interface IR11sSocketError {
 	 * The client should wait this many milliseconds before retrying its request.
 	 */
 	retryAfterMs?: number;
+
+	/**
+	 * Optional internalErrorCode to specify the specific error code for the error within the main code above.
+	 */
+	internalErrorCode?: string | number;
+}
+
+export class ClusterDrainingError extends LoggingError implements IFluidErrorBase {
+	readonly errorType = RouterliciousErrorTypes.clusterDrainingError;
+	readonly canRetry = true;
+
+	constructor(
+		message: string,
+		readonly retryAfterSeconds: number,
+		props: DriverErrorTelemetryProps,
+	) {
+		super(message, props);
+	}
 }
 
 export interface IR11sError extends Omit<IDriverErrorBase, "errorType"> {
@@ -78,9 +104,11 @@ export function createR11sNetworkError(
 	errorMessage: string,
 	statusCode: number,
 	retryAfterMs?: number,
+	additionalProps?: DriverErrorTelemetryProps,
+	internalErrorCode?: string | number,
 ): IFluidErrorBase & R11sError {
 	let error: IFluidErrorBase & R11sError;
-	const props = { statusCode, driverVersion };
+	const props = { ...additionalProps, statusCode, driverVersion };
 	switch (statusCode) {
 		case 401:
 		// The first 401 is manually retried in RouterliciousRestWrapper with a refreshed token,
@@ -99,6 +127,15 @@ export function createR11sNetworkError(
 		case 502:
 			error = new GenericNetworkError(errorMessage, true, props);
 			break;
+		case 503:
+			if (internalErrorCode === R11sServiceClusterDrainingErrorCode) {
+				error = new ClusterDrainingError(
+					errorMessage,
+					retryAfterMs !== undefined ? retryAfterMs / 1000 : 660,
+					props,
+				);
+				break;
+			}
 		default:
 			const retryInfo = { canRetry: retryAfterMs !== undefined, retryAfterMs };
 			error = createGenericNetworkError(errorMessage, retryInfo, props);
@@ -112,10 +149,9 @@ export function throwR11sNetworkError(
 	errorMessage: string,
 	statusCode: number,
 	retryAfterMs?: number,
+	additionalProps?: DriverErrorTelemetryProps,
 ): never {
-	const networkError = createR11sNetworkError(errorMessage, statusCode, retryAfterMs);
-
-	throw networkError;
+	throw createR11sNetworkError(errorMessage, statusCode, retryAfterMs, additionalProps);
 }
 
 /**
@@ -124,8 +160,69 @@ export function throwR11sNetworkError(
 export function errorObjectFromSocketError(
 	socketError: IR11sSocketError,
 	handler: string,
+	additionalProps?: DriverErrorTelemetryProps,
 ): R11sError {
 	// pre-0.58 error message prefix: R11sSocketError
 	const message = `R11s socket error (${handler}): ${socketError.message}`;
-	return createR11sNetworkError(message, socketError.code, socketError.retryAfterMs);
+	const error = createR11sNetworkError(
+		message,
+		socketError.code,
+		socketError.retryAfterMs,
+		additionalProps,
+		socketError.internalErrorCode,
+	);
+	error.addTelemetryProperties({
+		relayServiceError: true,
+		scenarioName: handler,
+		internalErrorCode: socketError.internalErrorCode,
+	});
+	return error;
+}
+
+/** Simulate the pathname for socket connection */
+export const socketIoPath = "socket.io";
+
+/**
+ * Get a stripped version of a URL safe for r11s telemetry
+ * @returns undefined if no appropriate hostName is provided
+ */
+export function getUrlForTelemetry(hostName: string, path: string = ""): string | undefined {
+	// Strip off "http://" or "https://"
+	const hostNameMatch = hostName.match(/^(?:https?:\/\/)?([^/]+)/);
+	if (!hostNameMatch) {
+		return undefined;
+	}
+	const strippedHostName = hostNameMatch[1];
+
+	let extractedPath = "";
+	// Extract portions of the path and explicitly match them to known path names
+	for (const portion of path.split("/")) {
+		if (portion !== "") {
+			// eslint-disable-next-line unicorn/prefer-ternary
+			if (
+				[
+					socketIoPath,
+					"repos",
+					"deltas",
+					"documents",
+					"session",
+					"git",
+					"summaries",
+					"latest",
+					"document",
+					"commits",
+					"blobs",
+					"refs",
+					"revokeToken",
+					"accesstoken",
+				].includes(portion)
+			) {
+				extractedPath += `/${portion}`;
+			} else {
+				extractedPath += "/REDACTED";
+			}
+		}
+	}
+
+	return `${strippedHostName}${extractedPath}`;
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/routerlicious-driver";
-export const pkgVersion = "2.5.0-302463";
+export const pkgVersion = "2.5.0";

package/src/restWrapper.ts

@@ -26,7 +26,11 @@ import fetch from "cross-fetch";
 import safeStringify from "json-stringify-safe";
 
 import type { AxiosRequestConfig, RawAxiosRequestHeaders } from "./axios.cjs";
-import { RouterliciousErrorTypes, throwR11sNetworkError } from "./errorUtils.js";
+import {
+	getUrlForTelemetry,
+	RouterliciousErrorTypes,
+	throwR11sNetworkError,
+} from "./errorUtils.js";
 import { pkgVersion as driverVersion } from "./packageVersion.js";
 import { addOrUpdateQueryParams, type QueryStringType } from "./queryStringUtils.js";
 import { RestWrapper } from "./restWrapperBase.js";
@@ -174,6 +178,13 @@ class RouterliciousRestWrapper extends RestWrapper {
 					// on failure, add the request entry into the retryCounter map to count the subsequent retries, if any
 					this.retryCounter.set(requestKey, requestRetryCount ? requestRetryCount + 1 : 1);
 
+					const telemetryProps = {
+						driverVersion,
+						retryCount: requestRetryCount,
+						url: getUrlForTelemetry(completeRequestUrl.hostname, completeRequestUrl.pathname),
+						requestMethod: fetchRequestConfig.method,
+					};
+
 					// Browser Fetch throws a TypeError on network error, `node-fetch` throws a FetchError
 					const isNetworkError = ["TypeError", "FetchError"].includes(error?.name);
 					const errorMessage = isNetworkError
@@ -185,14 +196,16 @@ class RouterliciousRestWrapper extends RestWrapper {
 					// If there exists a self-signed SSL certificates error, throw a NonRetryableError
 					// TODO: instead of relying on string matching, filter error based on the error code like we do for websocket connections
 					const err = errorMessage.includes("failed, reason: self signed certificate")
-						? new NonRetryableError(errorMessage, RouterliciousErrorTypes.sslCertError, {
-								driverVersion,
-								retryCount: requestRetryCount,
-							})
-						: new GenericNetworkError(errorMessage, errorMessage.startsWith("NetworkError"), {
-								driverVersion,
-								retryCount: requestRetryCount,
-							});
+						? new NonRetryableError(
+								errorMessage,
+								RouterliciousErrorTypes.sslCertError,
+								telemetryProps,
+							)
+						: new GenericNetworkError(
+								errorMessage,
+								errorMessage.startsWith("NetworkError"),
+								telemetryProps,
+							);
 					throw err;
 				},
 			);
@@ -203,6 +216,7 @@ class RouterliciousRestWrapper extends RestWrapper {
 		});
 
 		const response = res.response;
+		const headers = headersToMap(response.headers);
 
 		let start = performance.now();
 		const text = await response.text();
@@ -222,7 +236,6 @@ class RouterliciousRestWrapper extends RestWrapper {
 			// on successful response, remove the entry from the retryCounter map
 			this.retryCounter.delete(requestKey);
 			const result = responseBody as T;
-			const headers = headersToMap(response.headers);
 			return {
 				content: result,
 				headers,
@@ -268,6 +281,12 @@ class RouterliciousRestWrapper extends RestWrapper {
 			`R11s fetch error: ${responseSummary}`,
 			response.status,
 			responseBody?.retryAfter,
+			{
+				...getPropsToLogFromResponse(headers),
+				driverVersion,
+				url: getUrlForTelemetry(completeRequestUrl.hostname, completeRequestUrl.pathname),
+				requestMethod: fetchRequestConfig.method,
+			},
 		);
 	}
 

package/src/socketModule.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { io } from "socket.io-client";
+
+// Import is required for side-effects.
+export const SocketIOClientStatic = io;