@fluidframework/odsp-driver 2.0.0-dev-rc.1.0.0.232845 → 2.0.0-dev-rc.2.0.0.246488

package/src/localOdspDriver/localOdspDocumentServiceFactory.ts

@@ -6,19 +6,21 @@
 import { IDocumentService, IResolvedUrl } from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
-import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/core-interfaces";
-import { createOdspLogger, getOdspResolvedUrl } from "../odspUtils";
-import { ICacheAndTracker } from "../epochTracker";
-import { OdspDocumentServiceFactoryCore } from "../odspDocumentServiceFactoryCore";
-import { LocalOdspDocumentService } from "./localOdspDocumentService";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { createOdspLogger, getOdspResolvedUrl } from "../odspUtils.js";
+import { ICacheAndTracker } from "../epochTracker.js";
+import { OdspDocumentServiceFactoryCore } from "../odspDocumentServiceFactoryCore.js";
+import { LocalOdspDocumentService } from "./localOdspDocumentService.js";
 
 /**
  * Factory for creating sharepoint document service with a provided snapshot.
- * Use if you don't want to connect to any kind of external/internal storages and want to provide
+ *
+ * @remarks Use if you don't want to connect to any kind of external/internal storages and want to provide
  * content directly.
  */
 export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
-	private logger: ITelemetryLogger | undefined;
+	private readonly logger: ITelemetryLoggerExt = createOdspLogger();
 
 	constructor(private readonly localSnapshot: Uint8Array | string) {
 		super(
@@ -31,7 +33,7 @@ export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryC
 		const toThrow = new UsageError(
 			`${unsupportedFuncName} is not supported by LocalOdspDocumentServiceFactory`,
 		);
-		this.logger?.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
 		throw toThrow;
 	}
 
@@ -44,13 +46,13 @@ export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryC
 		const toThrow = new UsageError(
 			'"createContainer" is not supported by LocalOdspDocumentServiceFactory',
 		);
-		createOdspLogger(logger).sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
+		this.logger.sendErrorEvent({ eventName: "UnsupportedUsage" }, toThrow);
 		throw toThrow;
 	}
 
 	protected async createDocumentServiceCore(
 		resolvedUrl: IResolvedUrl,
-		odspLogger: ITelemetryLogger,
+		odspLogger: ITelemetryLoggerExt,
 		_cacheAndTrackerArg?: ICacheAndTracker,
 		_clientIsSummarizer?: boolean,
 	): Promise<IDocumentService> {
@@ -60,7 +62,6 @@ export class LocalOdspDocumentServiceFactory extends OdspDocumentServiceFactoryC
 		if (_clientIsSummarizer) {
 			throw new UsageError('Invalid usage. "_clientIsSummarizer" should not be provided');
 		}
-		this.logger = odspLogger;
 		return new LocalOdspDocumentService(
 			getOdspResolvedUrl(resolvedUrl),
 			odspLogger,

package/src/localOdspDriver/localOdspDocumentStorageManager.ts

@@ -12,10 +12,10 @@ import {
 } from "@fluidframework/driver-definitions";
 import { UsageError } from "@fluidframework/driver-utils";
 import * as api from "@fluidframework/protocol-definitions";
-import { OdspDocumentStorageServiceBase } from "../odspDocumentStorageServiceBase";
-import { IOdspSnapshot } from "../contracts";
-import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "../odspSnapshotParser";
-import { parseCompactSnapshotResponse } from "../compactSnapshotParser";
+import { OdspDocumentStorageServiceBase } from "../odspDocumentStorageServiceBase.js";
+import { IOdspSnapshot } from "../contracts.js";
+import { convertOdspSnapshotToSnapshotTreeAndBlobs } from "../odspSnapshotParser.js";
+import { parseCompactSnapshotResponse } from "../compactSnapshotParser.js";
 
 /**
  * ODSP document storage service that works on a provided snapshot for all its processing.
@@ -51,7 +51,7 @@ export class LocalOdspDocumentStorageService extends OdspDocumentStorageServiceB
 		let snapshotContents: ISnapshot;
 
 		if (typeof this.localSnapshot === "string") {
-			const content: IOdspSnapshot = JSON.parse(this.localSnapshot);
+			const content: IOdspSnapshot = JSON.parse(this.localSnapshot) as IOdspSnapshot;
 			snapshotContents = convertOdspSnapshotToSnapshotTreeAndBlobs(content);
 		} else {
 			snapshotContents = parseCompactSnapshotResponse(this.localSnapshot, this.logger);

package/src/odspCache.ts

@@ -2,6 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+
 import { PromiseCache } from "@fluidframework/core-utils";
 import {
 	IOdspResolvedUrl,
@@ -19,7 +20,11 @@ import { ISnapshot } from "@fluidframework/driver-definitions";
  * @alpha
  */
 export interface IPersistedFileCache {
+	// TODO: use a stronger type
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	get(entry: IEntry): Promise<any>;
+	// TODO: use a stronger type
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	put(entry: IEntry, value: any): Promise<void>;
 	removeEntries(): Promise<void>;
 }
@@ -29,19 +34,18 @@ export interface IPersistedFileCache {
  * used if no persisted cache is provided by the host
  */
 export class LocalPersistentCache implements IPersistedCache {
-	private readonly cache = new Map<string, any>();
+	private readonly cache = new Map<string, unknown>();
 	// For every document id there will be a single expiration entry inspite of the number of cache entries.
 	private readonly docIdExpirationMap = new Map<string, ReturnType<typeof setTimeout>>();
 
 	public constructor(private readonly snapshotExpiryPolicy = 3600 * 1000) {}
 
-	async get(entry: ICacheEntry): Promise<any> {
+	async get(entry: ICacheEntry): Promise<unknown> {
 		const key = getKeyForCacheEntry(entry);
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
 		return this.cache.get(key);
 	}
 
-	async put(entry: ICacheEntry, value: any) {
+	async put(entry: ICacheEntry, value: unknown): Promise<void> {
 		const key = getKeyForCacheEntry(entry);
 		this.cache.set(key, value);
 		this.updateExpirationEntry(entry.file.docId);
@@ -51,9 +55,9 @@ export class LocalPersistentCache implements IPersistedCache {
 		this.removeDocIdEntriesFromCache(file.docId);
 	}
 
-	private removeDocIdEntriesFromCache(docId: string) {
+	private removeDocIdEntriesFromCache(docId: string): void[] {
 		this.removeExpirationEntry(docId);
-		return Array.from(this.cache)
+		return [...this.cache]
 			.filter(([cachekey]) => {
 				const docIdFromKey = cachekey.split("_");
 				if (docIdFromKey[0] === docId) {
@@ -65,7 +69,7 @@ export class LocalPersistentCache implements IPersistedCache {
 			});
 	}
 
-	private removeExpirationEntry(docId: string) {
+	private removeExpirationEntry(docId: string): void {
 		const timeout = this.docIdExpirationMap.get(docId);
 		if (timeout !== undefined) {
 			clearTimeout(timeout);
@@ -73,7 +77,7 @@ export class LocalPersistentCache implements IPersistedCache {
 		}
 	}
 
-	private updateExpirationEntry(docId: string) {
+	private updateExpirationEntry(docId: string): void {
 		this.removeExpirationEntry(docId);
 		this.docIdExpirationMap.set(
 			docId,
@@ -84,7 +88,7 @@ export class LocalPersistentCache implements IPersistedCache {
 	}
 }
 export class PromiseCacheWithOneHourSlidingExpiry<T> extends PromiseCache<string, T> {
-	constructor(removeOnError?: (e: any) => boolean) {
+	constructor(removeOnError?: (error: unknown) => boolean) {
 		super({ expiry: { policy: "sliding", durationMs: 3600000 }, removeOnError });
 	}
 }

package/src/odspDelayLoadedDeltaStream.ts

@@ -32,19 +32,20 @@ import {
 	InstrumentedStorageTokenFetcher,
 	ISocketStorageDiscovery,
 	OdspErrorTypes,
+	type IOdspError,
 } from "@fluidframework/odsp-driver-definitions";
-import { hasFacetCodes } from "@fluidframework/odsp-doclib-utils";
-import { IOdspCache } from "./odspCache";
-import { OdspDocumentDeltaConnection } from "./odspDocumentDeltaConnection";
+import { hasFacetCodes } from "@fluidframework/odsp-doclib-utils/internal";
+import { IOdspCache } from "./odspCache.js";
+import { OdspDocumentDeltaConnection } from "./odspDocumentDeltaConnection.js";
 import {
 	getJoinSessionCacheKey,
 	getWithRetryForTokenRefresh,
 	TokenFetchOptionsEx,
-} from "./odspUtils";
-import { fetchJoinSession } from "./vroom";
-import { EpochTracker } from "./epochTracker";
-import { pkgVersion as driverVersion } from "./packageVersion";
-import { policyLabelsUpdatesSignalType } from "./contracts";
+} from "./odspUtils.js";
+import { fetchJoinSession } from "./vroom.js";
+import { EpochTracker } from "./epochTracker.js";
+import { pkgVersion as driverVersion } from "./packageVersion.js";
+import { policyLabelsUpdatesSignalType } from "./contracts.js";
 
 /**
  * This OdspDelayLoadedDeltaStream is used by OdspDocumentService.ts to delay load the delta connection
@@ -111,9 +112,11 @@ export class OdspDelayLoadedDeltaStream {
 		return this._relayServiceTenantAndSessionId;
 	}
 
-	/** Annotate the given error indicating which connection step failed */
+	/**
+	 * Annotate the given error indicating which connection step failed
+	 */
 	private annotateConnectionError(
-		error: any,
+		error: unknown,
 		failedConnectionStep: string,
 		separateTokenRequest: boolean,
 	): IFluidErrorBase {
@@ -141,10 +144,11 @@ export class OdspDelayLoadedDeltaStream {
 			// websocket token or whether it is returned with joinSession response payload
 			const requestWebsocketTokenFromJoinSession = this.getWebsocketToken === undefined;
 			const websocketTokenPromise = requestWebsocketTokenFromJoinSession
-				? Promise.resolve(null)
+				? // eslint-disable-next-line unicorn/no-null
+				  Promise.resolve(null)
 				: this.getWebsocketToken!(options);
 
-			const annotateAndRethrowConnectionError = (step: string) => (error: any) => {
+			const annotateAndRethrowConnectionError = (step: string) => (error: unknown) => {
 				throw this.annotateConnectionError(
 					error,
 					step,
@@ -162,6 +166,7 @@ export class OdspDelayLoadedDeltaStream {
 				websocketTokenPromise.catch(annotateAndRethrowConnectionError("getWebsocketToken")),
 			]);
 
+			// eslint-disable-next-line unicorn/no-null
 			const finalWebsocketToken = websocketToken ?? websocketEndpoint.socketToken ?? null;
 			if (finalWebsocketToken === null) {
 				throw this.annotateConnectionError(
@@ -195,13 +200,14 @@ export class OdspDelayLoadedDeltaStream {
 				this.signalHandler(connection.initialSignals);
 				// On disconnect with 401/403 error code, we can just clear the joinSession cache as we will again
 				// get the auth error on reconnecting and face latency.
-				connection.once("disconnect", (error: any) => {
+				connection.once("disconnect", (error: unknown) => {
 					// Clear the join session refresh timer so that it can be restarted on reconnection.
 					this.clearJoinSessionTimer();
 					if (
 						typeof error === "object" &&
 						error !== null &&
-						error.errorType === OdspErrorTypes.authorizationError
+						(error as Partial<IOdspError>).errorType ===
+							OdspErrorTypes.authorizationError
 					) {
 						this.cache.sessionJoinCache.remove(this.joinSessionKey);
 					}
@@ -231,9 +237,9 @@ export class OdspDelayLoadedDeltaStream {
 		});
 	}
 
-	private readonly signalHandler = (signalsArg: ISignalMessage | ISignalMessage[]) => {
+	private readonly signalHandler = (signalsArg: ISignalMessage | ISignalMessage[]): void => {
 		const signals = Array.isArray(signalsArg) ? signalsArg : [signalsArg];
-		signals.forEach((signal: ISignalMessage) => {
+		for (const signal of signals) {
 			// Make sure it is not for a specific client as `PolicyLabelsUpdate` is meant for all clients.
 			if (signal.clientId === null) {
 				// We could have some issues/irregularities in parsing signals, so put it in try/catch block
@@ -241,17 +247,19 @@ export class OdspDelayLoadedDeltaStream {
 				let envelope: ISignalEnvelope | undefined;
 				try {
 					envelope = JSON.parse(signal.content as string) as ISignalEnvelope;
-				} catch (err) {}
+				} catch {
+					// Drop error
+				}
 				if (envelope?.contents?.type === policyLabelsUpdatesSignalType) {
 					this.emitMetaDataUpdateEvent({
 						sensitivityLabelsInfo: JSON.stringify(envelope.contents.content),
 					});
 				}
 			}
-		});
+		}
 	};
 
-	private clearJoinSessionTimer() {
+	private clearJoinSessionTimer(): void {
 		if (this.joinSessionRefreshTimer !== undefined) {
 			clearTimeout(this.joinSessionRefreshTimer);
 			this.joinSessionRefreshTimer = undefined;
@@ -262,10 +270,13 @@ export class OdspDelayLoadedDeltaStream {
 		delta: number,
 		requestSocketToken: boolean,
 		clientId: string | undefined,
-	) {
+	): Promise<void> {
 		if (this.joinSessionRefreshTimer !== undefined) {
 			this.clearJoinSessionTimer();
+			// TODO: use a stronger type
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			const originalStackTraceLimit = (Error as any).stackTraceLimit;
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			(Error as any).stackTraceLimit = 50;
 			this.mc.logger.sendTelemetryEvent(
 				{
@@ -273,6 +284,7 @@ export class OdspDelayLoadedDeltaStream {
 				},
 				new Error("DuplicateJoinSessionRefresh"),
 			);
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
 			(Error as any).stackTraceLimit = originalStackTraceLimit;
 		}
 
@@ -300,7 +312,7 @@ export class OdspDelayLoadedDeltaStream {
 		options: TokenFetchOptionsEx,
 		isRefreshingJoinSession: boolean,
 		clientId?: string,
-	) {
+	): Promise<ISocketStorageDiscovery> {
 		// If this call is to refresh the join session for the current connection but we are already disconnected in
 		// the meantime or disconnected and then reconnected then do not make the call. However, we should not have
 		// come here if that is the case because timer should have been disposed, but due to race condition with the
@@ -327,16 +339,16 @@ export class OdspDelayLoadedDeltaStream {
 			requestSocketToken,
 			options,
 			isRefreshingJoinSession,
-		).catch((e) => {
-			if (hasFacetCodes(e) && e.facetCodes !== undefined) {
-				for (const code of e.facetCodes) {
+		).catch((error) => {
+			if (hasFacetCodes(error) && error.facetCodes !== undefined) {
+				for (const code of error.facetCodes) {
 					switch (code) {
 						case "sessionForbidden":
 						case "sessionForbiddenOnPreservedFiles":
 						case "sessionForbiddenOnModerationEnabledLibrary":
 						case "sessionForbiddenOnRequireCheckout":
 						case "sessionForbiddenOnCheckoutFile":
-						case "sessionForbiddenOnInvisibleMinorVersion":
+						case "sessionForbiddenOnInvisibleMinorVersion": {
 							// This document can only be opened in storage-only mode.
 							// DeltaManager will recognize this error
 							// and load without a delta stream connection.
@@ -346,12 +358,14 @@ export class OdspDelayLoadedDeltaStream {
 								{ driverVersion },
 								code,
 							);
-						default:
+						}
+						default: {
 							continue;
+						}
 					}
 				}
 			}
-			throw e;
+			throw error;
 		});
 		this._relayServiceTenantAndSessionId = `${response.tenantId}/${response.id}`;
 		return response;
@@ -365,7 +379,10 @@ export class OdspDelayLoadedDeltaStream {
 		const disableJoinSessionRefresh = this.mc.config.getBoolean(
 			"Fluid.Driver.Odsp.disableJoinSessionRefresh",
 		);
-		const executeFetch = async () => {
+		const executeFetch = async (): Promise<{
+			entryTime: number;
+			joinSessionResponse: ISocketStorageDiscovery;
+		}> => {
 			const joinSessionResponse = await fetchJoinSession(
 				this.odspResolvedUrl,
 				"opStream/joinSession",
@@ -391,7 +408,11 @@ export class OdspDelayLoadedDeltaStream {
 			};
 		};
 
-		const getResponseAndRefreshAfterDeltaMs = async () => {
+		const getResponseAndRefreshAfterDeltaMs = async (): Promise<{
+			refreshAfterDeltaMs: number;
+			entryTime: number;
+			joinSessionResponse: ISocketStorageDiscovery;
+		}> => {
 			const _response = await this.cache.sessionJoinCache.addOrGet(
 				this.joinSessionKey,
 				executeFetch,
@@ -448,13 +469,13 @@ export class OdspDelayLoadedDeltaStream {
 		return response.joinSessionResponse;
 	}
 
-	private emitMetaDataUpdateEvent(metadata: Record<string, string>) {
+	private emitMetaDataUpdateEvent(metadata: Record<string, string>): void {
 		const label = JSON.parse(metadata.sensitivityLabelsInfo) as {
 			labels: unknown;
 			timestamp: number;
 		};
 		const time = label.timestamp;
-		assert(time > 0, "time should be positive");
+		assert(time > 0, 0x8e0 /* time should be positive */);
 		if (time > this.labelUpdateTimestamp) {
 			this.labelUpdateTimestamp = time;
 			this.metadataUpdateHandler({
@@ -466,7 +487,7 @@ export class OdspDelayLoadedDeltaStream {
 	private calculateJoinSessionRefreshDelta(
 		responseFetchTime: number,
 		refreshSessionDurationSeconds: number,
-	) {
+	): number {
 		// 30 seconds is buffer time to refresh the session.
 		return responseFetchTime + (refreshSessionDurationSeconds * 1000 - 30000) - Date.now();
 	}
@@ -512,7 +533,7 @@ export class OdspDelayLoadedDeltaStream {
 		return connection;
 	}
 
-	public dispose(error?: any) {
+	public dispose(error?: unknown): void {
 		this.clearJoinSessionTimer();
 		this.currentConnection?.dispose();
 		this.currentConnection = undefined;

package/src/odspDeltaStorageService.ts

@@ -4,7 +4,7 @@
  */
 
 import { v4 as uuid } from "uuid";
-import { ITelemetryProperties } from "@fluidframework/core-interfaces";
+import { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import { validateMessages } from "@fluidframework/driver-base";
 import { ITelemetryLoggerExt, PerformanceEvent } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/core-utils";
@@ -13,12 +13,13 @@ import { InstrumentedStorageTokenFetcher } from "@fluidframework/odsp-driver-def
 import {
 	IDeltasFetchResult,
 	IDocumentDeltaStorageService,
+	type IStream,
 } from "@fluidframework/driver-definitions";
 import { requestOps, streamObserver } from "@fluidframework/driver-utils";
-import { IDeltaStorageGetResponse, ISequencedDeltaOpMessage } from "./contracts";
-import { EpochTracker } from "./epochTracker";
-import { getWithRetryForTokenRefresh } from "./odspUtils";
-import { OdspDocumentStorageService } from "./odspDocumentStorageManager";
+import { IDeltaStorageGetResponse, ISequencedDeltaOpMessage } from "./contracts.js";
+import { EpochTracker } from "./epochTracker.js";
+import { getWithRetryForTokenRefresh } from "./odspUtils.js";
+import { OdspDocumentStorageService } from "./odspDocumentStorageManager.js";
 
 /**
  * Provides access to the underlying delta storage on the server for sharepoint driver.
@@ -42,7 +43,7 @@ export class OdspDeltaStorageService {
 	public async get(
 		from: number,
 		to: number,
-		telemetryProps: ITelemetryProperties,
+		telemetryProps: ITelemetryBaseProperties,
 		scenarioName?: string,
 	): Promise<IDeltasFetchResult> {
 		return getWithRetryForTokenRefresh(async (options) => {
@@ -69,7 +70,7 @@ export class OdspDeltaStorageService {
 
 					postBody += `_post: 1\r\n`;
 					postBody += `\r\n--${formBoundary}--`;
-					const headers: { [index: string]: any } = {
+					const headers: { [index: string]: string } = {
 						"Content-Type": `multipart/form-data;boundary=${formBoundary}`,
 					};
 
@@ -105,7 +106,7 @@ export class OdspDeltaStorageService {
 							: (deltaStorageResponse.value as ISequencedDocumentMessage[]);
 
 					event.end({
-						headers: Object.keys(headers).length !== 0 ? true : undefined,
+						headers: Object.keys(headers).length > 0 ? true : undefined,
 						length: messages.length,
 						...response.propsToLog,
 					});
@@ -118,7 +119,7 @@ export class OdspDeltaStorageService {
 		});
 	}
 
-	public buildUrl(from: number, to: number) {
+	public buildUrl(from: number, to: number): string {
 		const filter = encodeURIComponent(
 			`sequenceNumber ge ${from} and sequenceNumber le ${to - 1}`,
 		);
@@ -138,7 +139,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		private readonly getFromStorage: (
 			from: number,
 			to: number,
-			telemetryProps: ITelemetryProperties,
+			telemetryProps: ITelemetryBaseProperties,
 			fetchReason?: string,
 		) => Promise<IDeltasFetchResult>,
 		private readonly getCached: (
@@ -156,7 +157,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		abortSignal?: AbortSignal,
 		cachedOnly?: boolean,
 		fetchReason?: string,
-	) {
+	): IStream<ISequencedDocumentMessage[]> {
 		// We do not control what's in the cache. Current API assumes that fetchMessages() keeps banging on
 		// storage / cache until it gets ops it needs. This would result in deadlock if fixed range is asked from
 		// cache and it's not there.
@@ -174,9 +175,9 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		const requestCallback = async (
 			from: number,
 			to: number,
-			telemetryProps: ITelemetryProperties,
-		) => {
-			if (this.snapshotOps !== undefined && this.snapshotOps.length !== 0) {
+			telemetryProps: ITelemetryBaseProperties,
+		): Promise<IDeltasFetchResult> => {
+			if (this.snapshotOps !== undefined && this.snapshotOps.length > 0) {
 				const messages = this.snapshotOps.filter(
 					(op) => op.sequenceNumber >= from && op.sequenceNumber < to,
 				);
@@ -200,7 +201,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 				// Set the firstCacheMiss as true in case we didn't get all the ops.
 				// This will save an extra cache read on "DocumentOpen" or "PostDocumentOpen".
 				this.useCacheForOps = from + messagesFromCache.length >= to;
-				if (messagesFromCache.length !== 0) {
+				if (messagesFromCache.length > 0) {
 					opsFromCache += messagesFromCache.length;
 					return {
 						messages: messagesFromCache,
@@ -221,7 +222,7 @@ export class OdspDeltaStorageWithCache implements IDocumentDeltaStorageService {
 		};
 
 		const stream = requestOps(
-			async (from: number, to: number, telemetryProps: ITelemetryProperties) => {
+			async (from: number, to: number, telemetryProps: ITelemetryBaseProperties) => {
 				const result = await requestCallback(from, to, telemetryProps);
 				// Catch all case, just in case
 				validateMessages("catch all", result.messages, from, this.logger);