@fluidframework/routerlicious-driver 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.2.0.153917

package/src/mapWithExpiration.ts

@@ -0,0 +1,124 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+
+/**
+ * An extension of Map that expires (deletes) entries after a period of inactivity.
+ * The policy is based on the last time a key was written to.
+ */
+export class MapWithExpiration<TKey = any, TValue = any> extends Map<TKey, TValue> {
+	/** Timestamps (as epoch ms numbers) of when each key was last refreshed */
+	private readonly lastRefreshedTimes = new Map<TKey, number>();
+
+	constructor(private readonly expiryMs: number) {
+		super();
+	}
+
+	private refresh(key: TKey): void {
+		this.lastRefreshedTimes.set(key, new Date().valueOf());
+	}
+
+	/**
+	 * Returns true if the key is present and expired, false if it's not expired, and undefined if it's not found
+	 * If cleanUp is passed as true, then delete any expired entry before returning.
+	 */
+	private checkExpiry(key: TKey, cleanUp: boolean = false): boolean | undefined {
+		const refreshTime = this.lastRefreshedTimes.get(key);
+		assert(
+			(refreshTime !== undefined) === super.has(key),
+			0x50c /* freshness map out of sync */,
+		);
+
+		if (refreshTime === undefined) {
+			return undefined;
+		}
+		const expired = new Date().valueOf() - refreshTime >= this.expiryMs;
+		if (expired && cleanUp) {
+			this.delete(key);
+		}
+		return expired;
+	}
+
+	private clearExpiredEntries() {
+		// forEach clears out any expired entries
+		this.forEach(() => {});
+	}
+
+	get size(): number {
+		this.clearExpiredEntries();
+		return super.size;
+	}
+
+	has(key: TKey): boolean {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.has(key);
+	}
+
+	get(key: TKey): TValue | undefined {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.get(key);
+	}
+
+	set(key: TKey, value: TValue): this {
+		// Sliding window expiration policy (on write)
+		this.refresh(key);
+		return super.set(key, value);
+	}
+
+	delete(key: TKey): boolean {
+		this.lastRefreshedTimes.delete(key);
+		return super.delete(key);
+	}
+
+	clear(): void {
+		this.lastRefreshedTimes.clear();
+		super.clear();
+	}
+
+	forEach(
+		callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void,
+		thisArg?: any,
+	): void {
+		const expiredKeys: TKey[] = [];
+		super.forEach(
+			(v, k, m) => {
+				if (this.checkExpiry(k) === true) {
+					expiredKeys.push(k);
+				} else {
+					callbackfn.bind(thisArg)(v, k, m);
+				}
+			},
+			// Note we don't pass thisArg here, since we bind it directly to callbackFn and don't need it otherwise
+		);
+
+		// Clean up keys we know are expired now that we're done iterating
+		expiredKeys.forEach((key: TKey) => {
+			this.delete(key);
+		});
+	}
+
+	entries(): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super.entries();
+	}
+	keys(): IterableIterator<TKey> {
+		this.clearExpiredEntries();
+		return super.keys();
+	}
+	values(): IterableIterator<TValue> {
+		this.clearExpiredEntries();
+		return super.values();
+	}
+	[Symbol.iterator](): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super[Symbol.iterator]();
+	}
+
+	valueOf() {
+		this.clearExpiredEntries();
+		return super.valueOf();
+	}
+}

package/src/packageVersion.ts

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

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, "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>;