@fluidframework/container-runtime 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/src/connectionTelemetry.ts

@@ -3,15 +3,22 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { ChildLogger, TelemetryLogger } from "@fluidframework/telemetry-utils";
+import {
+	IEventSampler,
+	ISampledTelemetryLogger,
+	ITelemetryLoggerExt,
+	createChildLogger,
+	createSampledLogger,
+	formatTick,
+} from "@fluidframework/telemetry-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import {
-    IDocumentMessage,
-    ISequencedDocumentMessage,
-    MessageType,
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	MessageType,
 } from "@fluidframework/protocol-definitions";
-import { assert, performance } from "@fluidframework/common-utils";
+import { assert } from "@fluidframework/core-utils";
+import { performance } from "@fluid-internal/client-utils";
 
 /**
  * We report various latency-related errors when waiting for op roundtrip takes longer than that amout of time.
@@ -26,263 +33,346 @@ export const latencyThreshold = 5000;
 // 3.	Op received from service back (pushed to inbound queue).
 // 4.	Op is processed.
 interface IOpPerfTelemetryProperties {
-    /** Measure time between (1) and (2) - Measure time outbound op is sitting in queue due to active batch */
-    durationOutboundBatching: number; // was durationOutboundQueue in previous versions
-    /** Measure time between (2) and (3) - Track how long it took for op to be acked by service */
-    durationNetwork: number; // was durationInboundQueue
-    /** Measure time between (3) and (4) - Time between DM's inbound "push" event until DM's "op" event */
-    durationInboundToProcessing: number;
-    /** Length of the DeltaManager's inbound queue at the time of the DM's inbound "push" event (3) */
-    lengthInboundQueue: number;
+	/** Measure time between (1) and (2) - Measure time outbound op is sitting in queue due to active batch */
+	durationOutboundBatching: number; // was durationOutboundQueue in previous versions
+	/** Measure time between (2) and (3) - Track how long it took for op to be acked by service */
+	durationNetwork: number; // was durationInboundQueue
+	/** Measure time between (3) and (4) - Time between DM's inbound "push" event until DM's "op" event */
+	durationInboundToProcessing: number;
+	/** Length of the DeltaManager's inbound queue at the time of the DM's inbound "push" event (3) */
+	lengthInboundQueue: number;
 }
 
 /**
  * Timings collected at various moments during the op processing.
  */
- interface IOpPerfTimings {
-     /** Starting time for (1) */
-    submitOpEventTime: number;
-     /** Starting time for (2) */
-     outboundPushEventTime: number;
-     /** Starting time for (3) */
-     inboundPushEventTime: number;
+interface IOpPerfTimings {
+	/** Starting time for (1) */
+	submitOpEventTime: number;
+	/** Starting time for (2) */
+	outboundPushEventTime: number;
+	/** Starting time for (3) */
+	inboundPushEventTime: number;
 }
 
 class OpPerfTelemetry {
-    private pongCount: number = 0;
-    private pingLatency: number | undefined;
-
-    // Collab window tracking. This is timestamp of %1000 message.
-    private sequenceNumberForMsnTracking: number | undefined;
-    private msnTrackingTimestamp: number = 0;
-    // To track round trip time for every %500 client message.
-    private clientSequenceNumberForLatencyStatistics: number | undefined;
-
-    private opProcessingTimes: Partial<IOpPerfTimings> = {};
-
-    // Performance Data to be reported for ops round trips and processing.
-    private opPerfData: Partial<IOpPerfTelemetryProperties> = {};
-
-    private firstConnection = true;
-    private connectionOpSeqNumber: number | undefined;
-    private readonly bootTime = performance.now();
-    private connectionStartTime = 0;
-    private gap = 0;
-
-    private readonly logger: ITelemetryLogger;
-
-    public constructor(
-        private clientId: string | undefined,
-        private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-        logger: ITelemetryLogger) {
-        this.logger = ChildLogger.create(logger, "OpPerf");
-
-        this.deltaManager.on("pong", (latency) => this.recordPingTime(latency));
-        this.deltaManager.on("submitOp", (message) => this.beforeOpSubmit(message));
-
-        this.deltaManager.on("op", (message) => this.afterProcessingOp(message));
-
-        this.deltaManager.on("connect", (details, opsBehind) => {
-            this.clientId = details.clientId;
-            if (opsBehind !== undefined) {
-                this.connectionOpSeqNumber = this.deltaManager.lastKnownSeqNumber;
-                this.gap = opsBehind;
-                this.connectionStartTime = performance.now();
-
-                // We might be already up-today. If so, report it right away.
-                if (this.gap <= 0) {
-                    this.reportGettingUpToDate();
-                }
-            }
-        });
-        this.deltaManager.on("disconnect", () => {
-            this.sequenceNumberForMsnTracking = undefined;
-            this.clientSequenceNumberForLatencyStatistics = undefined;
-            this.opProcessingTimes = {};
-            this.opPerfData = {};
-            this.connectionOpSeqNumber = undefined;
-            this.firstConnection = false;
-            this.pongCount = 0;
-        });
-
-        this.deltaManager.outbound.on("push", (messages) => {
-            for (const msg of messages) {
-                if (msg.type === MessageType.Operation &&
-                    this.clientSequenceNumberForLatencyStatistics === msg.clientSequenceNumber) {
-                    assert(this.opProcessingTimes.outboundPushEventTime === undefined,
-                        0x2c8 /* "outboundPushEventTime should be undefined" */);
-                    assert(this.opPerfData.durationNetwork === undefined,
-                        0x2c9 /* "durationNetwork should be undefined" */);
-                    this.opProcessingTimes.outboundPushEventTime = Date.now();
-
-                    assert(this.opPerfData.durationOutboundBatching === undefined,
-                        0x2ca /* "durationOutboundBatching should be undefined" */);
-
-                    assert(this.opProcessingTimes.submitOpEventTime !== undefined,
-                        0x2cb /* "submitOpEventTime should be undefined" */);
-
-                    this.opPerfData.durationOutboundBatching = this.opProcessingTimes.outboundPushEventTime
-                        - this.opProcessingTimes.submitOpEventTime;
-                }
-            }
-        });
-
-        this.deltaManager.inbound.on("push", (message: ISequencedDocumentMessage) => {
-            if (this.clientId === message.clientId &&
-                message.type === MessageType.Operation &&
-                this.clientSequenceNumberForLatencyStatistics === message.clientSequenceNumber &&
-                this.opProcessingTimes.outboundPushEventTime !== undefined) {
-                this.opProcessingTimes.inboundPushEventTime = Date.now();
-                this.opPerfData.durationNetwork = this.opProcessingTimes.inboundPushEventTime
-                                     - this.opProcessingTimes.outboundPushEventTime;
-                this.opProcessingTimes.outboundPushEventTime = undefined;
-                this.opPerfData.lengthInboundQueue = this.deltaManager.inbound.length;
-            }
-        });
-
-        this.deltaManager.inbound.on("idle", (count: number, duration: number) => {
-            // Do not want to log zero for sure.
-            // We are more interested in aggregates, so logging only if we are processing some number of ops
-            // Cut-off is arbitrary - can be increased or decreased based on amount of data collected and questions we
-            // want to get answered
-            // back-compat: Once 0.36 loader version saturates (count & duration args were added there),
-            // we can remove typeof check.
-            if (typeof count === "number" && count >= 100) {
-                this.logger.sendPerformanceEvent({
-                    eventName: "GetDeltas_OpProcessing",
-                    count,
-                    duration,
-                });
-            }
-        });
-    }
-
-    private reportGettingUpToDate() {
-        this.connectionOpSeqNumber = undefined;
-        this.logger.sendPerformanceEvent({
-            eventName: "ConnectionSpeed",
-            duration: performance.now() - this.connectionStartTime,
-            ops: this.gap,
-            // track time to connect only for first connection.
-            timeToConnect: this.firstConnection ?
-                TelemetryLogger.formatTick(this.connectionStartTime - this.bootTime) :
-                undefined,
-            firstConnection: this.firstConnection,
-        });
-    }
-
-    private recordPingTime(latency: number) {
-        this.pingLatency = latency;
-        // logging one in every 1000 pongs, including the first time, if it is a "write" client.
-        if (this.pongCount % 100 === 0 && this.deltaManager.active) {
-            this.logger.sendPerformanceEvent({
-                eventName: "DeltaLatency",
-                duration: latency,
-            });
-        }
-        this.pongCount++;
-    }
-
-    private beforeOpSubmit(message: IDocumentMessage) {
-        // start with first client op and measure latency every 500 client ops
-        if (this.clientSequenceNumberForLatencyStatistics === undefined &&
-            message.clientSequenceNumber % 500 === 1) {
-            assert(this.opProcessingTimes.outboundPushEventTime === undefined,
-                0x2cc /* "OpTimeSittingInboundQueue should be undefined" */);
-            assert(this.opPerfData.durationNetwork === undefined,
-                0x2cd /* "durationNetwork should be undefined" */);
-            this.opProcessingTimes.submitOpEventTime = Date.now();
-            this.clientSequenceNumberForLatencyStatistics = message.clientSequenceNumber;
-        }
-    }
-
-    private afterProcessingOp(message: ISequencedDocumentMessage) {
-        const sequenceNumber = message.sequenceNumber;
-
-        if (sequenceNumber === this.connectionOpSeqNumber) {
-            this.reportGettingUpToDate();
-        }
-
-        // Record collab window max size after every 1000th op.
-        if (this.sequenceNumberForMsnTracking === undefined && sequenceNumber % 1000 === 0) {
-            this.sequenceNumberForMsnTracking = sequenceNumber;
-            this.msnTrackingTimestamp = message.timestamp;
-        }
-        if (this.sequenceNumberForMsnTracking !== undefined &&
-                message.minimumSequenceNumber >= this.sequenceNumberForMsnTracking) {
-            assert(this.msnTrackingTimestamp !== undefined,
-                0x2ce /* "msnTrackingTimestamp should not be undefined" */);
-            this.logger.sendPerformanceEvent({
-                eventName: "MsnStatistics",
-                sequenceNumber,
-                msnDistance: sequenceNumber - this.sequenceNumberForMsnTracking,
-                duration: message.timestamp - this.msnTrackingTimestamp,
-            });
-            this.sequenceNumberForMsnTracking = undefined;
-        }
-
-        if (this.clientId === message.clientId &&
-            this.clientSequenceNumberForLatencyStatistics === message.clientSequenceNumber) {
-            assert(this.opProcessingTimes.submitOpEventTime !== undefined,
-                0x120 /* "Undefined latency statistics (op send time)" */);
-            const currentTime = Date.now();
-
-            if (this.opProcessingTimes.inboundPushEventTime !== undefined) {
-                this.opPerfData.durationInboundToProcessing = currentTime
-                - this.opProcessingTimes.inboundPushEventTime;
-            }
-
-            const duration = currentTime - this.opProcessingTimes.submitOpEventTime;
-
-            // One of the core expectations for Fluid service is to be fast.
-            // When it's not the case, we want to learn about it and be able to investigate, so
-            // raise awareness.
-            // This also helps identify cases where it's due to client behavior (sending too many ops)
-            // that results in overwhelming ordering service and thus starting to see long latencies.
-            // The threshold could be adjusted, but ideally it stays  workload-agnostic, as service
-            // performance impacts all workloads relying on service.
-            const category = duration > latencyThreshold ? "error" : "performance";
-
-            this.logger.sendPerformanceEvent({
-                eventName: "OpRoundtripTime",
-                sequenceNumber,
-                referenceSequenceNumber: message.referenceSequenceNumber,
-                duration,
-                category,
-                pingLatency: this.pingLatency,
-                msnDistance: this.deltaManager.lastSequenceNumber - this.deltaManager.minimumSequenceNumber,
-                ...this.opPerfData,
-            });
-            this.clientSequenceNumberForLatencyStatistics = undefined;
-            this.opPerfData = {};
-        }
-    }
+	private pingLatency: number | undefined;
+
+	// Collab window tracking. This is timestamp of %1000 message.
+	private sequenceNumberForMsnTracking: number | undefined;
+	private msnTrackingTimestamp: number = 0;
+	// To track round trip time for every %500 client message.
+	private clientSequenceNumberForLatencyStatistics: number | undefined;
+	// Performance Data to be reported for ops round trips and processing.
+	private readonly latencyStatistics = new Map<
+		number,
+		{
+			opProcessingTimes: Partial<IOpPerfTimings>;
+			opPerfData: Partial<IOpPerfTelemetryProperties>;
+		}
+	>();
+
+	private firstConnection = true;
+	private connectionOpSeqNumber: number | undefined;
+	private readonly bootTime = performance.now();
+	private connectionStartTime = 0;
+	private gap = 0;
+
+	private readonly logger: ITelemetryLoggerExt;
+
+	private static readonly OP_LATENCY_SAMPLE_RATE = 500;
+	private readonly opLatencyLogger: ISampledTelemetryLogger;
+
+	private static readonly DELTA_LATENCY_SAMPLE_RATE = 100;
+	private readonly deltaLatencyLogger: ISampledTelemetryLogger;
+
+	public constructor(
+		private clientId: string | undefined,
+		private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+		logger: ITelemetryLoggerExt,
+	) {
+		this.logger = createChildLogger({ logger, namespace: "OpPerf" });
+
+		const deltaLatencyEventSampler: IEventSampler = (() => {
+			let eventCount = -1;
+			return {
+				sample: () => {
+					eventCount++;
+					const shouldSample =
+						eventCount % OpPerfTelemetry.DELTA_LATENCY_SAMPLE_RATE === 0;
+					if (shouldSample) {
+						eventCount = 0;
+					}
+					return shouldSample;
+				},
+			};
+		})();
+
+		this.deltaLatencyLogger = createSampledLogger(logger, deltaLatencyEventSampler);
+
+		// The SampledLogger here is used get access to the isSamplingDisabled property derived from
+		// telemetry config properties. The actual sampling logic for op messages happens outside this SampledLogger
+		// due to complexity of the different asynchronus scenarios of the op message lifecycle.
+		this.opLatencyLogger = createSampledLogger(logger);
+
+		this.deltaManager.on("pong", (latency) => this.recordPingTime(latency));
+		this.deltaManager.on("submitOp", (message) => this.beforeOpSubmit(message));
+
+		this.deltaManager.on("op", (message) => this.afterProcessingOp(message));
+
+		this.deltaManager.on("connect", (details, opsBehind) => {
+			this.clientId = details.clientId;
+			if (opsBehind !== undefined) {
+				this.connectionOpSeqNumber = this.deltaManager.lastKnownSeqNumber;
+				this.gap = opsBehind;
+				this.connectionStartTime = performance.now();
+
+				// We might be already up-today. If so, report it right away.
+				if (this.gap <= 0) {
+					this.reportGettingUpToDate();
+				}
+			}
+		});
+		this.deltaManager.on("disconnect", () => {
+			this.sequenceNumberForMsnTracking = undefined;
+			this.clientSequenceNumberForLatencyStatistics = undefined;
+			this.connectionOpSeqNumber = undefined;
+			this.firstConnection = false;
+			this.latencyStatistics.clear();
+		});
+
+		this.deltaManager.outbound.on("push", (messages) => {
+			for (const msg of messages) {
+				if (
+					msg.type === MessageType.Operation &&
+					(this.opLatencyLogger.isSamplingDisabled ||
+						this.clientSequenceNumberForLatencyStatistics === msg.clientSequenceNumber)
+				) {
+					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+					const latencyStats = this.latencyStatistics.get(msg.clientSequenceNumber)!;
+					assert(
+						latencyStats !== undefined,
+						0x7c2 /* Latency stats for op should exist */,
+					);
+					assert(
+						latencyStats.opProcessingTimes.outboundPushEventTime === undefined,
+						0x2c8 /* "outboundPushEventTime should be undefined" */,
+					);
+					assert(
+						latencyStats.opPerfData.durationNetwork === undefined,
+						0x2c9 /* "durationNetwork should be undefined" */,
+					);
+					latencyStats.opProcessingTimes.outboundPushEventTime = Date.now();
+
+					assert(
+						latencyStats.opPerfData.durationOutboundBatching === undefined,
+						0x2ca /* "durationOutboundBatching should be undefined" */,
+					);
+
+					assert(
+						latencyStats.opProcessingTimes.submitOpEventTime !== undefined,
+						0x2cb /* "submitOpEventTime should be undefined" */,
+					);
+
+					latencyStats.opPerfData.durationOutboundBatching =
+						latencyStats.opProcessingTimes.outboundPushEventTime -
+						latencyStats.opProcessingTimes.submitOpEventTime;
+				}
+			}
+		});
+
+		this.deltaManager.inbound.on("push", (message: ISequencedDocumentMessage) => {
+			if (
+				this.clientId === message.clientId &&
+				message.type === MessageType.Operation &&
+				(this.opLatencyLogger.isSamplingDisabled ||
+					this.clientSequenceNumberForLatencyStatistics === message.clientSequenceNumber)
+			) {
+				// We do an explicit check for undefined right after this
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				const latencyStats = this.latencyStatistics.get(message.clientSequenceNumber)!;
+				assert(latencyStats !== undefined, 0x7c3 /* Latency stats for op should exist */);
+				if (latencyStats.opProcessingTimes.outboundPushEventTime !== undefined) {
+					latencyStats.opProcessingTimes.inboundPushEventTime = Date.now();
+					latencyStats.opPerfData.durationNetwork =
+						latencyStats.opProcessingTimes.inboundPushEventTime -
+						latencyStats.opProcessingTimes.outboundPushEventTime;
+					latencyStats.opPerfData.lengthInboundQueue = this.deltaManager.inbound.length;
+				}
+			}
+		});
+
+		this.deltaManager.inbound.on("idle", (count: number, duration: number) => {
+			// Do not want to log zero for sure.
+			// We are more interested in aggregates, so logging only if we are processing some number of ops
+			// Cut-off is arbitrary - can be increased or decreased based on amount of data collected and questions we
+			// want to get answered
+			// back-compat: Once 0.36 loader version saturates (count & duration args were added there),
+			// we can remove typeof check.
+			if (typeof count === "number" && count >= 100) {
+				this.logger.sendPerformanceEvent({
+					eventName: "GetDeltas_OpProcessing",
+					count,
+					duration,
+				});
+			}
+		});
+	}
+
+	private reportGettingUpToDate() {
+		this.connectionOpSeqNumber = undefined;
+		this.logger.sendPerformanceEvent({
+			eventName: "ConnectionSpeed",
+			duration: performance.now() - this.connectionStartTime,
+			ops: this.gap,
+			// track time to connect only for first connection.
+			timeToConnect: this.firstConnection
+				? formatTick(this.connectionStartTime - this.bootTime)
+				: undefined,
+			firstConnection: this.firstConnection,
+		});
+	}
+
+	private recordPingTime(latency: number) {
+		this.pingLatency = latency;
+
+		// Log if latency is longer than 1 min
+		if (latency > 1000 * 60) {
+			this.logger.sendErrorEvent({
+				eventName: "LatencyTooLong",
+				duration: latency,
+			});
+		}
+
+		// logging one in every DELTA_LATENCY_SAMPLE_RATE pongs, including the first time, if it is a "write" client.
+		if (this.deltaManager.active) {
+			this.deltaLatencyLogger.sendPerformanceEvent({
+				eventName: "DeltaLatency",
+				duration: latency,
+			});
+		}
+	}
+
+	private beforeOpSubmit(message: IDocumentMessage) {
+		// start with first client op and measure latency every 500 client ops
+		if (
+			this.opLatencyLogger.isSamplingDisabled ||
+			(this.clientSequenceNumberForLatencyStatistics === undefined &&
+				message.clientSequenceNumber % OpPerfTelemetry.OP_LATENCY_SAMPLE_RATE === 1)
+		) {
+			assert(
+				this.latencyStatistics.get(message.clientSequenceNumber) === undefined,
+				0x7c4 /* Existing op perf data for client sequence number */,
+			);
+			this.clientSequenceNumberForLatencyStatistics = message.clientSequenceNumber;
+			this.latencyStatistics.set(message.clientSequenceNumber, {
+				opProcessingTimes: {
+					submitOpEventTime: Date.now(),
+				},
+				opPerfData: {},
+			});
+		}
+	}
+
+	private afterProcessingOp(message: ISequencedDocumentMessage) {
+		const sequenceNumber = message.sequenceNumber;
+
+		if (sequenceNumber === this.connectionOpSeqNumber) {
+			this.reportGettingUpToDate();
+		}
+
+		// Record collab window max size after every 1000th op.
+		if (this.sequenceNumberForMsnTracking === undefined && sequenceNumber % 1000 === 0) {
+			this.sequenceNumberForMsnTracking = sequenceNumber;
+			this.msnTrackingTimestamp = message.timestamp;
+		}
+		if (
+			this.sequenceNumberForMsnTracking !== undefined &&
+			message.minimumSequenceNumber >= this.sequenceNumberForMsnTracking
+		) {
+			assert(
+				this.msnTrackingTimestamp !== undefined,
+				0x2ce /* "msnTrackingTimestamp should not be undefined" */,
+			);
+			this.logger.sendPerformanceEvent({
+				eventName: "MsnStatistics",
+				sequenceNumber,
+				msnDistance: sequenceNumber - this.sequenceNumberForMsnTracking,
+				duration: message.timestamp - this.msnTrackingTimestamp,
+			});
+			this.sequenceNumberForMsnTracking = undefined;
+		}
+
+		if (
+			this.clientId === message.clientId &&
+			(this.opLatencyLogger.isSamplingDisabled ||
+				this.clientSequenceNumberForLatencyStatistics === message.clientSequenceNumber)
+		) {
+			// We do an explicit check for undefined right after this
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const latencyData = this.latencyStatistics.get(message.clientSequenceNumber)!;
+			assert(latencyData !== undefined, 0x7c5 /* Undefined latency statistics for op */);
+			assert(
+				latencyData.opProcessingTimes.submitOpEventTime !== undefined,
+				0x120 /* "Undefined latency statistics for op (op send time)" */,
+			);
+			const currentTime = Date.now();
+			if (latencyData.opProcessingTimes.inboundPushEventTime !== undefined) {
+				latencyData.opPerfData.durationInboundToProcessing =
+					currentTime - latencyData.opProcessingTimes.inboundPushEventTime;
+			}
+			const duration = currentTime - latencyData.opProcessingTimes.submitOpEventTime;
+
+			// One of the core expectations for Fluid service is to be fast.
+			// When it's not the case, we want to learn about it and be able to investigate, so
+			// raise awareness.
+			// This also helps identify cases where it's due to client behavior (sending too many ops)
+			// that results in overwhelming ordering service and thus starting to see long latencies.
+			// The threshold could be adjusted, but ideally it stays  workload-agnostic, as service
+			// performance impacts all workloads relying on service.
+			const category = duration > latencyThreshold ? "error" : "performance";
+			this.opLatencyLogger.sendPerformanceEvent({
+				eventName: "OpRoundtripTime",
+				sequenceNumber,
+				referenceSequenceNumber: message.referenceSequenceNumber,
+				duration,
+				category,
+				pingLatency: this.pingLatency,
+				msnDistance:
+					this.deltaManager.lastSequenceNumber - this.deltaManager.minimumSequenceNumber,
+				...latencyData.opPerfData,
+			});
+			this.clientSequenceNumberForLatencyStatistics = undefined;
+			this.latencyStatistics.delete(message.clientSequenceNumber);
+		}
+	}
 }
 export interface IPerfSignalReport {
-    /**
-     * Identifier for the signal being submitted in order to
-     * allow collection of data around the roundtrip of signal messages.
-     */
-    signalSequenceNumber: number;
-    /**
-     * Number of signals that were expected but not received.
-     */
-    signalsLost: number;
-
-    /**
-     * Timestamp before submitting the signal we will trace.
-     */
-    signalTimestamp: number;
-
-    /**
-     * Expected Signal Sequence to be received.
-     */
-    trackingSignalSequenceNumber: number | undefined;
+	/**
+	 * Identifier for the signal being submitted in order to
+	 * allow collection of data around the roundtrip of signal messages.
+	 */
+	signalSequenceNumber: number;
+	/**
+	 * Number of signals that were expected but not received.
+	 */
+	signalsLost: number;
+
+	/**
+	 * Timestamp before submitting the signal we will trace.
+	 */
+	signalTimestamp: number;
+
+	/**
+	 * Expected Signal Sequence to be received.
+	 */
+	trackingSignalSequenceNumber: number | undefined;
 }
 
 export function ReportOpPerfTelemetry(
-    clientId: string | undefined,
-    deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-    logger: ITelemetryLogger) {
-    new OpPerfTelemetry(clientId, deltaManager, logger);
+	clientId: string | undefined,
+	deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+	logger: ITelemetryLoggerExt,
+) {
+	new OpPerfTelemetry(clientId, deltaManager, logger);
 }