@fluidframework/routerlicious-driver 2.0.0-dev.4.1.0.148229 → 2.0.0-dev.4.3.0.157531

package/src/restWrapper.ts

@@ -3,19 +3,14 @@
  * Licensed under the MIT License.
  */
 
-// Just using the type from a node.js module does not introduce a runtime dependency.
-// eslint-disable-next-line import/no-nodejs-modules
-import type { ParsedUrlQueryInput } from "querystring";
-
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { fromUtf8ToBase64 } from "@fluidframework/common-utils";
+import { ITelemetryLogger, ITelemetryProperties } from "@fluidframework/common-definitions";
+import { assert, fromUtf8ToBase64, performance } from "@fluidframework/common-utils";
 import { RateLimiter } from "@fluidframework/driver-utils";
 import {
 	getAuthorizationTokenFromCredentials,
 	RestLessClient,
-	RestWrapper,
 } from "@fluidframework/server-services-client";
-import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+import { PerformanceEvent, TelemetryLogger } from "@fluidframework/telemetry-utils";
 import fetch from "cross-fetch";
 import type { AxiosRequestConfig, AxiosRequestHeaders } from "axios";
 import safeStringify from "json-stringify-safe";
@@ -23,6 +18,7 @@ import { v4 as uuid } from "uuid";
 import { throwR11sNetworkError } from "./errorUtils";
 import { ITokenProvider, ITokenResponse } from "./tokens";
 import { pkgVersion as driverVersion } from "./packageVersion";
+import { QueryStringType, RestWrapper } from "./restWrapperBase";
 
 type AuthorizationHeaderGetter = (token: ITokenResponse) => string;
 type TokenFetcher = (refresh?: boolean) => Promise<ITokenResponse>;
@@ -44,18 +40,75 @@ const axiosRequestConfigToFetchRequestConfig = (
 	return [requestInfo, requestInit];
 };
 
+export interface IR11sResponse<T> {
+	content: T;
+	headers: Map<string, string>;
+	propsToLog: ITelemetryProperties;
+	requestUrl: string;
+}
+
+/**
+ * A utility function to create a r11s response without any additional props as we might not have them always.
+ * @param content - response which is equivalent to content.
+ * @returns - a r11s response without any extra props.
+ */
+export function createR11sResponseFromContent<T>(content: T): IR11sResponse<T> {
+	return {
+		content,
+		headers: new Map(),
+		propsToLog: {},
+		requestUrl: "",
+	};
+}
+
+function headersToMap(headers: Headers) {
+	const newHeaders = new Map<string, string>();
+	for (const [key, value] of headers.entries()) {
+		newHeaders.set(key, value);
+	}
+	return newHeaders;
+}
+
+export function getPropsToLogFromResponse(headers: {
+	get: (id: string) => string | undefined | null;
+}) {
+	interface LoggingHeader {
+		headerName: string;
+		logName: string;
+	}
+
+	// We rename headers so that otel doesn't scrub them away. Otel doesn't allow
+	// certain characters in headers including '-'
+	const headersToLog: LoggingHeader[] = [
+		{ headerName: "x-correlation-id", logName: "requestCorrelationId" },
+		{ headerName: "content-encoding", logName: "contentEncoding" },
+		{ headerName: "content-type", logName: "contentType" },
+	];
+	const additionalProps: ITelemetryProperties = {
+		contentsize: TelemetryLogger.numberFromString(headers.get("content-length")),
+	};
+	headersToLog.forEach((header) => {
+		const headerValue = headers.get(header.headerName);
+		if (headerValue !== undefined && headerValue !== null) {
+			additionalProps[header.logName] = headerValue;
+		}
+	});
+
+	return additionalProps;
+}
+
 export class RouterliciousRestWrapper extends RestWrapper {
 	private readonly restLess = new RestLessClient();
+	private token: ITokenResponse | undefined;
 
 	constructor(
 		logger: ITelemetryLogger,
 		private readonly rateLimiter: RateLimiter,
-		private token: ITokenResponse,
 		private readonly fetchRefreshedToken: TokenFetcher,
 		private readonly getAuthorizationHeader: AuthorizationHeaderGetter,
 		private readonly useRestLess: boolean,
 		baseurl?: string,
-		defaultQueryString: ParsedUrlQueryInput = {},
+		defaultQueryString: QueryStringType = {},
 	) {
 		super(baseurl, defaultQueryString);
 	}
@@ -64,33 +117,59 @@ export class RouterliciousRestWrapper extends RestWrapper {
 		requestConfig: AxiosRequestConfig,
 		statusCode: number,
 		canRetry = true,
-	): Promise<T> {
+	): Promise<IR11sResponse<T>> {
 		const config = {
 			...requestConfig,
-			headers: this.generateHeaders(requestConfig.headers),
+			headers: await this.generateHeaders(requestConfig.headers),
 		};
 
 		const translatedConfig = this.useRestLess ? this.restLess.translate(config) : config;
 		const fetchRequestConfig = axiosRequestConfigToFetchRequestConfig(translatedConfig);
 
-		const response: Response = await this.rateLimiter.schedule(async () =>
-			fetch(...fetchRequestConfig).catch(async (error) => {
+		const res = await this.rateLimiter.schedule(async () => {
+			const perfStart = performance.now();
+			const result = await fetch(...fetchRequestConfig).catch(async (error) => {
 				// Browser Fetch throws a TypeError on network error, `node-fetch` throws a FetchError
 				const isNetworkError = ["TypeError", "FetchError"].includes(error?.name);
 				throwR11sNetworkError(
 					isNetworkError ? `NetworkError: ${error.message}` : safeStringify(error),
 				);
-			}),
-		);
+			});
+			return {
+				response: result,
+				duration: performance.now() - perfStart,
+			};
+		});
+
+		const response = res.response;
 
+		let start = performance.now();
+		const text = await response.text();
+		const receiveContentTime = performance.now() - start;
+
+		const bodySize = text.length;
+		start = performance.now();
 		const responseBody: any = response.headers.get("content-type")?.includes("application/json")
-			? await response.json()
-			: await response.text();
+			? JSON.parse(text)
+			: text;
+		const parseTime = performance.now() - start;
 
 		// Success
 		if (response.ok || response.status === statusCode) {
-			const result: T = responseBody;
-			return result;
+			const result = responseBody as T;
+			const headers = headersToMap(response.headers);
+			return {
+				content: result,
+				headers,
+				requestUrl: fetchRequestConfig[0].toString(),
+				propsToLog: {
+					...getPropsToLogFromResponse(headers),
+					bodySize,
+					receiveContentTime,
+					parseTime,
+					fetchTime: res.duration,
+				},
+			};
 		}
 		// Failure
 		if (response.status === 401 && canRetry) {
@@ -100,7 +179,7 @@ export class RouterliciousRestWrapper extends RestWrapper {
 		}
 		if (response.status === 429 && responseBody?.retryAfter > 0) {
 			// Retry based on retryAfter[Seconds]
-			return new Promise<T>((resolve, reject) =>
+			return new Promise<IR11sResponse<T>>((resolve, reject) =>
 				setTimeout(() => {
 					this.request<T>(config, statusCode).then(resolve).catch(reject);
 				}, responseBody.retryAfter * 1000),
@@ -120,9 +199,11 @@ export class RouterliciousRestWrapper extends RestWrapper {
 		);
 	}
 
-	private generateHeaders(
+	private async generateHeaders(
 		requestHeaders?: AxiosRequestHeaders | undefined,
-	): Record<string, string> {
+	): Promise<Record<string, string>> {
+		const token = await this.getToken();
+		assert(token !== undefined, 0x679 /* token should be present */);
 		const correlationId = requestHeaders?.["x-correlation-id"] ?? uuid();
 
 		return {
@@ -132,12 +213,17 @@ export class RouterliciousRestWrapper extends RestWrapper {
 			"x-correlation-id": correlationId as string,
 			"x-driver-version": driverVersion,
 			// NOTE: If this.authorizationHeader is undefined, should "Authorization" be removed entirely?
-			"Authorization": this.getAuthorizationHeader(this.token),
+			"Authorization": this.getAuthorizationHeader(token),
 		};
 	}
 
-	public getToken(): ITokenResponse {
-		return this.token;
+	public async getToken(): Promise<ITokenResponse> {
+		if (this.token !== undefined) {
+			return this.token;
+		}
+		const token = await this.fetchRefreshedToken();
+		this.setToken(token);
+		return token;
 	}
 
 	public setToken(token: ITokenResponse) {
@@ -149,17 +235,15 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
 	private constructor(
 		logger: ITelemetryLogger,
 		rateLimiter: RateLimiter,
-		token: ITokenResponse,
 		fetchToken: TokenFetcher,
 		getAuthorizationHeader: AuthorizationHeaderGetter,
 		useRestLess: boolean,
 		baseurl?: string,
-		defaultQueryString: ParsedUrlQueryInput = {},
+		defaultQueryString: QueryStringType = {},
 	) {
 		super(
 			logger,
 			rateLimiter,
-			token,
 			fetchToken,
 			getAuthorizationHeader,
 			useRestLess,
@@ -211,12 +295,9 @@ export class RouterliciousStorageRestWrapper extends RouterliciousRestWrapper {
 			return getAuthorizationTokenFromCredentials(credentials);
 		};
 
-		const storagetoken = await fetchStorageToken();
-
 		const restWrapper = new RouterliciousStorageRestWrapper(
 			logger,
 			rateLimiter,
-			storagetoken,
 			fetchStorageToken,
 			getAuthorizationHeader,
 			useRestLess,
@@ -232,17 +313,15 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
 	private constructor(
 		logger: ITelemetryLogger,
 		rateLimiter: RateLimiter,
-		token: ITokenResponse,
 		fetchToken: TokenFetcher,
 		getAuthorizationHeader: AuthorizationHeaderGetter,
 		useRestLess: boolean,
 		baseurl?: string,
-		defaultQueryString: ParsedUrlQueryInput = {},
+		defaultQueryString: QueryStringType = {},
 	) {
 		super(
 			logger,
 			rateLimiter,
-			token,
 			fetchToken,
 			getAuthorizationHeader,
 			useRestLess,
@@ -285,12 +364,9 @@ export class RouterliciousOrdererRestWrapper extends RouterliciousRestWrapper {
 			);
 		};
 
-		const newtoken = await fetchOrdererToken();
-
 		const restWrapper = new RouterliciousOrdererRestWrapper(
 			logger,
 			rateLimiter,
-			newtoken,
 			fetchOrdererToken,
 			getAuthorizationHeader,
 			useRestLess,

package/src/restWrapperBase.ts

@@ -0,0 +1,146 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { AxiosRequestConfig, AxiosRequestHeaders } from "axios";
+import { IR11sResponse } from "./restWrapper";
+
+export abstract class RestWrapper {
+	constructor(
+		protected readonly baseurl?: string,
+		protected defaultQueryString: QueryStringType = {},
+		protected readonly maxBodyLength = 1000 * 1024 * 1024,
+		protected readonly maxContentLength = 1000 * 1024 * 1024,
+	) {}
+
+	public async get<T>(
+		url: string,
+		queryString?: QueryStringType,
+		headers?: AxiosRequestHeaders,
+		additionalOptions?: Partial<
+			Omit<
+				AxiosRequestConfig,
+				"baseURL" | "headers" | "maxBodyLength" | "maxContentLength" | "method" | "url"
+			>
+		>,
+	): Promise<IR11sResponse<T>> {
+		const options: AxiosRequestConfig = {
+			...additionalOptions,
+			baseURL: this.baseurl,
+			headers,
+			maxBodyLength: this.maxBodyLength,
+			maxContentLength: this.maxContentLength,
+			method: "GET",
+			url: `${url}${this.generateQueryString(queryString)}`,
+		};
+		return this.request<T>(options, 200);
+	}
+
+	public async post<T>(
+		url: string,
+		requestBody: any,
+		queryString?: QueryStringType,
+		headers?: AxiosRequestHeaders,
+		additionalOptions?: Partial<
+			Omit<
+				AxiosRequestConfig,
+				"baseURL" | "headers" | "maxBodyLength" | "maxContentLength" | "method" | "url"
+			>
+		>,
+	): Promise<IR11sResponse<T>> {
+		const options: AxiosRequestConfig = {
+			...additionalOptions,
+			baseURL: this.baseurl,
+			data: requestBody,
+			headers,
+			maxBodyLength: this.maxBodyLength,
+			maxContentLength: this.maxContentLength,
+			method: "POST",
+			url: `${url}${this.generateQueryString(queryString)}`,
+		};
+		return this.request<T>(options, 201);
+	}
+
+	public async delete<T>(
+		url: string,
+		queryString?: QueryStringType,
+		headers?: AxiosRequestHeaders,
+		additionalOptions?: Partial<
+			Omit<
+				AxiosRequestConfig,
+				"baseURL" | "headers" | "maxBodyLength" | "maxContentLength" | "method" | "url"
+			>
+		>,
+	): Promise<IR11sResponse<T>> {
+		const options: AxiosRequestConfig = {
+			...additionalOptions,
+			baseURL: this.baseurl,
+			headers,
+			maxBodyLength: this.maxBodyLength,
+			maxContentLength: this.maxContentLength,
+			method: "DELETE",
+			url: `${url}${this.generateQueryString(queryString)}`,
+		};
+		return this.request<T>(options, 204);
+	}
+
+	public async patch<T>(
+		url: string,
+		requestBody: any,
+		queryString?: QueryStringType,
+		headers?: AxiosRequestHeaders,
+		additionalOptions?: Partial<
+			Omit<
+				AxiosRequestConfig,
+				"baseURL" | "headers" | "maxBodyLength" | "maxContentLength" | "method" | "url"
+			>
+		>,
+	): Promise<IR11sResponse<T>> {
+		const options: AxiosRequestConfig = {
+			...additionalOptions,
+			baseURL: this.baseurl,
+			data: requestBody,
+			headers,
+			maxBodyLength: this.maxBodyLength,
+			maxContentLength: this.maxContentLength,
+			method: "PATCH",
+			url: `${url}${this.generateQueryString(queryString)}`,
+		};
+		return this.request<T>(options, 200);
+	}
+
+	protected abstract request<T>(
+		options: AxiosRequestConfig,
+		statusCode: number,
+		addNetworkCallProps?: boolean,
+	): Promise<IR11sResponse<T>>;
+
+	protected generateQueryString(queryStringValues?: QueryStringType) {
+		if (this.defaultQueryString || queryStringValues) {
+			const queryStringMap = { ...this.defaultQueryString, ...queryStringValues };
+
+			return getQueryString(queryStringMap);
+		}
+
+		return "";
+	}
+}
+
+/**
+ * Generates query string from the given query parameters.
+ * @param queryParams - Query parameters from which to create a query.
+ */
+export function getQueryString(queryParams: QueryStringType): string {
+	let queryString = "";
+	for (const key of Object.keys(queryParams)) {
+		if (queryParams[key] !== undefined) {
+			const startChar = queryString === "" ? "?" : "&";
+			queryString += `${startChar}${key}=${encodeURIComponent(queryParams[key])}`;
+		}
+	}
+
+	return queryString;
+}
+
+export type QueryStringType = Record<string, string | number | boolean>;

package/src/retriableGitManager.ts

@@ -4,15 +4,15 @@
  */
 
 import type * as git from "@fluidframework/gitresources";
-import type * as protocol from "@fluidframework/protocol-definitions";
 import {
-	IGitManager,
 	IWholeFlatSummary,
 	IWholeSummaryPayload,
 	IWriteSummaryResponse,
 } from "@fluidframework/server-services-client";
 import { runWithRetry } from "@fluidframework/driver-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { IGitManager } from "./storageContracts";
+import { IR11sResponse } from "./restWrapper";
 
 export class RetriableGitManager implements IGitManager {
 	constructor(
@@ -20,135 +20,57 @@ export class RetriableGitManager implements IGitManager {
 		private readonly logger: ITelemetryLogger,
 	) {}
 
-	public async getHeader(id: string, sha: string): Promise<protocol.ISnapshotTree> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.getHeader(id, sha),
-			"gitManager_getHeader",
-		);
-	}
-
-	public async getFullTree(sha: string): Promise<any> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.getFullTree(sha),
-			"gitManager_getFullTree",
-		);
-	}
-
-	public async getCommit(sha: string): Promise<git.ICommit> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.getCommit(sha),
-			"gitManager_getCommit",
-		);
-	}
-
-	public async getCommits(sha: string, count: number): Promise<git.ICommitDetails[]> {
+	public async getCommits(
+		sha: string,
+		count: number,
+	): Promise<IR11sResponse<git.ICommitDetails[]>> {
 		return this.runWithRetry(
 			async () => this.internalGitManager.getCommits(sha, count),
 			"gitManager_getCommits",
 		);
 	}
 
-	public async getTree(root: string, recursive: boolean): Promise<git.ITree> {
+	public async getTree(root: string, recursive: boolean): Promise<IR11sResponse<git.ITree>> {
 		return this.runWithRetry(
 			async () => this.internalGitManager.getTree(root, recursive),
 			"gitManager_getTree",
 		);
 	}
 
-	public async getBlob(sha: string): Promise<git.IBlob> {
+	public async getBlob(sha: string): Promise<IR11sResponse<git.IBlob>> {
 		return this.runWithRetry(
 			async () => this.internalGitManager.getBlob(sha),
 			"gitManager_getBlob",
 		);
 	}
 
-	public getRawUrl(sha: string): string {
-		return this.internalGitManager.getRawUrl(sha);
-	}
-
-	public async getContent(commit: string, path: string): Promise<git.IBlob> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.getContent(commit, path),
-			"gitManager_getContent",
-		);
-	}
-
-	public async createBlob(content: string, encoding: string): Promise<git.ICreateBlobResponse> {
+	public async createBlob(
+		content: string,
+		encoding: string,
+	): Promise<IR11sResponse<git.ICreateBlobResponse>> {
 		return this.runWithRetry(
 			async () => this.internalGitManager.createBlob(content, encoding),
 			"gitManager_createBlob",
 		);
 	}
 
-	public async createGitTree(params: git.ICreateTreeParams): Promise<git.ITree> {
+	public async createGitTree(params: git.ICreateTreeParams): Promise<IR11sResponse<git.ITree>> {
 		return this.runWithRetry(
 			async () => this.internalGitManager.createGitTree(params),
 			"gitManager_createGitTree",
 		);
 	}
 
-	public async createTree(files: protocol.ITree): Promise<git.ITree> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.createTree(files),
-			"gitManager_createTree",
-		);
-	}
-
-	public async createCommit(commit: git.ICreateCommitParams): Promise<git.ICommit> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.createCommit(commit),
-			"gitManager_createCommit",
-		);
-	}
-
-	public async getRef(ref: string): Promise<git.IRef> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.getRef(ref),
-			"gitManager_getRef",
-		);
-	}
-
-	public async createRef(branch: string, sha: string): Promise<git.IRef> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.createRef(branch, sha),
-			"gitManager_createRef",
-		);
-	}
-
-	public async upsertRef(branch: string, commitSha: string): Promise<git.IRef> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.upsertRef(branch, commitSha),
-			"gitManager_upsertRef",
-		);
-	}
-
-	public async write(
-		branch: string,
-		inputTree: protocol.ITree,
-		parents: string[],
-		message: string,
-	): Promise<git.ICommit> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.write(branch, inputTree, parents, message),
-			"gitManager_write",
-		);
-	}
-
-	public async createSummary(summary: IWholeSummaryPayload): Promise<IWriteSummaryResponse> {
+	public async createSummary(
+		summary: IWholeSummaryPayload,
+	): Promise<IR11sResponse<IWriteSummaryResponse>> {
 		return this.runWithRetry(
 			async () => this.internalGitManager.createSummary(summary),
 			"gitManager_createSummary",
 		);
 	}
 
-	public async deleteSummary(softDelete: boolean): Promise<void> {
-		return this.runWithRetry(
-			async () => this.internalGitManager.deleteSummary(softDelete),
-			"gitManager_deleteSummary",
-		);
-	}
-
-	public async getSummary(sha: string): Promise<IWholeFlatSummary> {
+	public async getSummary(sha: string): Promise<IR11sResponse<IWholeFlatSummary>> {
 		return this.runWithRetry(
 			async () => this.internalGitManager.getSummary(sha),
 			"gitManager_getSummary",

package/src/shreddedSummaryDocumentStorageService.ts

@@ -18,16 +18,14 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import {
-	GitManager,
-	ISummaryUploadManager,
-	SummaryTreeUploadManager,
-} from "@fluidframework/server-services-client";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { IRouterliciousDriverPolicies } from "./policies";
 import { ICache, InMemoryCache } from "./cache";
 import { RetriableGitManager } from "./retriableGitManager";
 import { ISnapshotTreeVersion } from "./definitions";
+import { GitManager } from "./gitManager";
+import { ISummaryUploadManager } from "./storageContracts";
+import { SummaryTreeUploadManager } from "./summaryTreeUploadManager";
 
 const isNode = typeof window === "undefined";
 
@@ -85,7 +83,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
 			},
 			async () => {
 				const manager = await this.getStorageManager();
-				return manager.getCommits(id, count);
+				return (await manager.getCommits(id, count)).content;
 			},
 		);
 		return commits.map((commit) => ({
@@ -121,7 +119,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
 			},
 			async (event) => {
 				const manager = await this.getStorageManager();
-				const response = await manager.getTree(requestVersion!.treeId);
+				const response = (await manager.getTree(requestVersion!.treeId)).content;
 				event.end({
 					size: response.tree.length,
 				});
@@ -150,7 +148,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
 			},
 			async (event) => {
 				const manager = await this.getStorageManager();
-				const response = await manager.getBlob(blobId);
+				const response = (await manager.getBlob(blobId)).content;
 				event.end({
 					size: response.size,
 				});
@@ -203,7 +201,7 @@ export class ShreddedSummaryDocumentStorageService implements IDocumentStorageSe
 				const manager = await this.getStorageManager();
 				const response = await manager
 					.createBlob(Uint8ArrayToString(uint8ArrayFile, "base64"), "base64")
-					.then((r) => ({ id: r.sha, url: r.url }));
+					.then((r) => ({ id: r.content.sha, url: r.content.url }));
 				event.end({
 					blobId: response.id,
 				});