@fluidframework/telemetry-utils 2.0.0-dev.4.4.0.162574 → 2.0.0-dev.5.3.2.178189

package/src/config.ts

@@ -2,9 +2,10 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { Lazy } from "@fluidframework/common-utils";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { Lazy } from "@fluidframework/core-utils";
 import { TelemetryDataTag } from "./logger";
+import { ITelemetryLoggerExt } from "./telemetryTypes";
 
 export type ConfigTypes = string | number | boolean | number[] | string[] | boolean[] | undefined;
 
@@ -240,19 +241,19 @@ export class CachedConfigProvider implements IConfigProvider {
 /**
  * A type containing both a telemetry logger and a configuration provider
  */
-export interface MonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLogger> {
+export interface MonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt> {
 	config: IConfigProvider;
 	logger: L;
 }
 
-export function loggerIsMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLogger>(
+export function loggerIsMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(
 	obj: L,
 ): obj is L & MonitoringContext<L> {
 	const maybeConfig = obj as Partial<MonitoringContext<L>> | undefined;
 	return isConfigProviderBase(maybeConfig?.config) && maybeConfig?.logger !== undefined;
 }
 
-export function loggerToMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLogger>(
+export function loggerToMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(
 	logger: L,
 ): MonitoringContext<L> {
 	if (loggerIsMonitoringContext<L>(logger)) {
@@ -261,7 +262,7 @@ export function loggerToMonitoringContext<L extends ITelemetryBaseLogger = ITele
 	return mixinMonitoringContext<L>(logger, sessionStorageConfigProvider.value);
 }
 
-export function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLogger>(
+export function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(
 	logger: L,
 	...configs: (IConfigProviderBase | undefined)[]
 ) {

package/src/debugLogger.ts

@@ -7,7 +7,7 @@ import {
 	ITelemetryBaseEvent,
 	ITelemetryBaseLogger,
 	ITelemetryProperties,
-} from "@fluidframework/common-definitions";
+} from "@fluidframework/core-interfaces";
 import { performance } from "@fluidframework/common-utils";
 import { debug as registerDebug, IDebugger } from "debug";
 import {

package/src/errorLogging.ts

@@ -6,10 +6,9 @@
 import {
 	ILoggingError,
 	ITaggedTelemetryPropertyType,
-	ITelemetryLogger,
 	ITelemetryProperties,
 	TelemetryEventPropertyType,
-} from "@fluidframework/common-definitions";
+} from "@fluidframework/core-interfaces";
 import { v4 as uuid } from "uuid";
 import {
 	hasErrorInstanceId,
@@ -17,7 +16,11 @@ import {
 	isFluidError,
 	isValidLegacyError,
 } from "./fluidErrorBase";
-import { ITaggedTelemetryPropertyTypeExt, TelemetryEventPropertyTypeExt } from "./telemetryTypes";
+import {
+	ITaggedTelemetryPropertyTypeExt,
+	ITelemetryLoggerExt,
+	TelemetryEventPropertyTypeExt,
+} from "./telemetryTypes";
 
 /** @returns true if value is an object but neither null nor an array */
 const isRegularObject = (value: any): boolean => {
@@ -121,8 +124,19 @@ export function normalizeError(
 	// Anywhere they are set should be on a valid Fluid Error that would have been returned above,
 	// but we can't prove it with the types, so adding this defensive measure.
 	if (typeof error === "object" && error !== null) {
-		const { canRetry, retryAfterSeconds } = error as any;
-		Object.assign(normalizeError, { canRetry, retryAfterSeconds });
+		const maybeHasRetry: Partial<Record<"canRetry" | "retryAfterSeconds", unknown>> = error;
+		let retryProps: Partial<Record<"canRetry" | "retryAfterSeconds", unknown>> | undefined;
+		if ("canRetry" in error) {
+			retryProps ??= {};
+			retryProps.canRetry = maybeHasRetry.canRetry;
+		}
+		if ("retryAfterSeconds" in error) {
+			retryProps ??= {};
+			retryProps.retryAfterSeconds = maybeHasRetry.retryAfterSeconds;
+		}
+		if (retryProps !== undefined) {
+			Object.assign(fluidError, retryProps);
+		}
 	}
 
 	if (typeof error !== "object") {
@@ -220,7 +234,7 @@ export function wrapError<T extends LoggingError>(
 export function wrapErrorAndLog<T extends LoggingError>(
 	innerError: unknown,
 	newErrorFn: (message: string) => T,
-	logger: ITelemetryLogger,
+	logger: ITelemetryLoggerExt,
 ) {
 	const newError = wrapError(innerError, newErrorFn);
 

package/src/events.ts

@@ -4,14 +4,14 @@
  */
 
 import { EventEmitter } from "events";
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ITelemetryLoggerExt } from "./telemetryTypes";
 
 export const connectedEventName = "connected";
 export const disconnectedEventName = "disconnected";
 
 export function safeRaiseEvent(
 	emitter: EventEmitter,
-	logger: ITelemetryLogger,
+	logger: ITelemetryLoggerExt,
 	event: string,
 	...args
 ) {
@@ -31,7 +31,7 @@ export function safeRaiseEvent(
  * @param disconnectedReason - The reason for the connection to be disconnected (Used for telemetry purposes only)
  */
 export function raiseConnectedEvent(
-	logger: ITelemetryLogger,
+	logger: ITelemetryLoggerExt,
 	emitter: EventEmitter,
 	connected: boolean,
 	clientId?: string,

package/src/fluidErrorBase.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryProperties } from "@fluidframework/common-definitions";
+import { ITelemetryProperties } from "@fluidframework/core-interfaces";
 
 /**
  * All normalized errors flowing through the Fluid Framework adhere to this readonly interface.

package/src/logger.ts

@@ -8,14 +8,13 @@ import {
 	ITelemetryBaseLogger,
 	ITelemetryErrorEvent,
 	ITelemetryGenericEvent,
-	ITelemetryLogger,
 	ITelemetryPerformanceEvent,
 	ITelemetryProperties,
 	TelemetryEventPropertyType,
 	ITaggedTelemetryPropertyType,
 	TelemetryEventCategory,
-} from "@fluidframework/common-definitions";
-import { performance } from "@fluidframework/common-utils";
+} from "@fluidframework/core-interfaces";
+import { IsomorphicPerformance, performance } from "@fluidframework/common-utils";
 import { CachedConfigProvider, loggerIsMonitoringContext, mixinMonitoringContext } from "./config";
 import {
 	isILoggingError,
@@ -32,6 +31,13 @@ import {
 	TelemetryEventPropertyTypeExt,
 } from "./telemetryTypes";
 
+export interface Memory {
+	usedJSHeapSize: number;
+}
+
+export interface PerformanceWithMemory extends IsomorphicPerformance {
+	readonly memory: Memory;
+}
 /**
  * Broad classifications to be applied to individual properties as they're prepared to be logged to telemetry.
  * Please do not modify existing entries for backwards compatibility.
@@ -290,7 +296,6 @@ export class ChildLogger extends TelemetryLogger {
 	 * is created, but it does not send telemetry events anywhere.
 	 * @param namespace - Telemetry event name prefix to add to all events
 	 * @param properties - Base properties to add to all events
-	 * @param propertyGetters - Getters to add additional properties to all events
 	 */
 	public static create(
 		baseLogger?: ITelemetryBaseLogger,
@@ -361,7 +366,6 @@ export class ChildLogger extends TelemetryLogger {
 /**
  * Multi-sink logger
  * Takes multiple ITelemetryBaseLogger objects (sinks) and logs all events into each sink
- * Implements ITelemetryBaseLogger (through static create() method)
  */
 export class MultiSinkLogger extends TelemetryLogger {
 	protected loggers: ITelemetryBaseLogger[] = [];
@@ -370,7 +374,6 @@ export class MultiSinkLogger extends TelemetryLogger {
 	 * Create multiple sink logger (i.e. logger that sends events to multiple sinks)
 	 * @param namespace - Telemetry event name prefix to add to all events
 	 * @param properties - Base properties to add to all events
-	 * @param propertyGetters - Getters to add additional properties to all events
 	 */
 	constructor(namespace?: string, properties?: ITelemetryLoggerPropertyBags) {
 		super(namespace, properties);
@@ -416,15 +419,16 @@ export interface IPerformanceEventMarkers {
  */
 export class PerformanceEvent {
 	public static start(
-		logger: ITelemetryLogger,
+		logger: ITelemetryLoggerExt,
 		event: ITelemetryGenericEvent,
 		markers?: IPerformanceEventMarkers,
+		recordHeapSize: boolean = false,
 	) {
-		return new PerformanceEvent(logger, event, markers);
+		return new PerformanceEvent(logger, event, markers, recordHeapSize);
 	}
 
 	public static timedExec<T>(
-		logger: ITelemetryLogger,
+		logger: ITelemetryLoggerExt,
 		event: ITelemetryGenericEvent,
 		callback: (event: PerformanceEvent) => T,
 		markers?: IPerformanceEventMarkers,
@@ -441,12 +445,13 @@ export class PerformanceEvent {
 	}
 
 	public static async timedExecAsync<T>(
-		logger: ITelemetryLogger,
+		logger: ITelemetryLoggerExt,
 		event: ITelemetryGenericEvent,
 		callback: (event: PerformanceEvent) => Promise<T>,
 		markers?: IPerformanceEventMarkers,
+		recordHeapSize?: boolean,
 	) {
-		const perfEvent = PerformanceEvent.start(logger, event, markers);
+		const perfEvent = PerformanceEvent.start(logger, event, markers, recordHeapSize);
 		try {
 			const ret = await callback(perfEvent);
 			perfEvent.autoEnd();
@@ -464,11 +469,13 @@ export class PerformanceEvent {
 	private event?: ITelemetryGenericEvent;
 	private readonly startTime = performance.now();
 	private startMark?: string;
+	private startMemoryCollection: number | undefined = 0;
 
 	protected constructor(
-		private readonly logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLoggerExt,
 		event: ITelemetryGenericEvent,
 		private readonly markers: IPerformanceEventMarkers = { end: true, cancel: "generic" },
+		private readonly recordHeapSize: boolean = false,
 	) {
 		this.event = { ...event };
 		if (this.markers.start) {
@@ -531,6 +538,20 @@ export class PerformanceEvent {
 		event.eventName = `${event.eventName}_${eventNameSuffix}`;
 		if (eventNameSuffix !== "start") {
 			event.duration = this.duration;
+			if (this.startMemoryCollection) {
+				const currentMemory = (performance as PerformanceWithMemory)?.memory
+					?.usedJSHeapSize;
+				const differenceInKBytes = Math.floor(
+					(currentMemory - this.startMemoryCollection) / 1024,
+				);
+				if (differenceInKBytes > 0) {
+					event.usedJSHeapSize = differenceInKBytes;
+				}
+			}
+		} else if (this.recordHeapSize) {
+			this.startMemoryCollection = (
+				performance as PerformanceWithMemory
+			)?.memory?.usedJSHeapSize;
 		}
 
 		this.logger.sendPerformanceEvent(event, error);
@@ -541,7 +562,7 @@ export class PerformanceEvent {
  * Logger that is useful for UT
  * It can be used in places where logger instance is required, but events should be not send over.
  */
-export class TelemetryUTLogger implements ITelemetryLogger {
+export class TelemetryUTLogger implements ITelemetryLoggerExt {
 	public send(event: ITelemetryBaseEvent): void {}
 	public sendTelemetryEvent(event: ITelemetryGenericEvent, error?: any) {}
 	public sendErrorEvent(event: ITelemetryErrorEvent, error?: any) {
@@ -591,7 +612,7 @@ export class BaseTelemetryNullLogger implements ITelemetryBaseLogger {
  * Null logger
  * It can be used in places where logger instance is required, but events should be not send over.
  */
-export class TelemetryNullLogger implements ITelemetryLogger {
+export class TelemetryNullLogger implements ITelemetryLoggerExt {
 	public send(event: ITelemetryBaseEvent): void {}
 	public sendTelemetryEvent(event: ITelemetryGenericEvent, error?: any): void {}
 	public sendErrorEvent(event: ITelemetryErrorEvent, error?: any): void {}
@@ -645,7 +666,7 @@ function convertToBasePropertyTypeUntagged(
 		case "undefined":
 			return x;
 		case "object":
-			// We assume this is an array based on the input types
+			// We assume this is an array or flat object based on the input types
 			return JSON.stringify(x);
 		default:
 			// should never reach this case based on the input types

package/src/mockLogger.ts

@@ -3,15 +3,16 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger, ITelemetryBaseEvent } from "@fluidframework/common-definitions";
+import { ITelemetryBaseEvent } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/common-utils";
 import { TelemetryLogger } from "./logger";
+import { ITelemetryLoggerExt } from "./telemetryTypes";
 
 /**
  * The MockLogger records events sent to it, and then can walk back over those events
  * searching for a set of expected events to match against the logged events.
  */
-export class MockLogger extends TelemetryLogger implements ITelemetryLogger {
+export class MockLogger extends TelemetryLogger implements ITelemetryLoggerExt {
 	events: ITelemetryBaseEvent[] = [];
 
 	constructor() {
@@ -191,7 +192,7 @@ ${JSON.stringify(actualEvents)}`);
 		if (inlineDetailsProp && details !== undefined) {
 			assert(
 				typeof details === "string",
-				"Details should a JSON stringified string if inlineDetailsProp is true",
+				0x6c9 /* Details should a JSON stringified string if inlineDetailsProp is true */,
 			);
 			detailsExpanded = JSON.parse(details);
 		}

package/src/sampledTelemetryHelper.ts

@@ -4,13 +4,13 @@
  */
 
 import {
-	IDisposable,
 	ITelemetryGenericEvent,
-	ITelemetryLogger,
 	ITelemetryPerformanceEvent,
 	ITelemetryProperties,
-} from "@fluidframework/common-definitions";
+	IDisposable,
+} from "@fluidframework/core-interfaces";
 import { performance } from "@fluidframework/common-utils";
+import { ITelemetryLoggerExt } from "./telemetryTypes";
 
 interface Measurements {
 	// The names of the properties in this interface are the ones that will get stamped in the
@@ -75,7 +75,7 @@ export class SampledTelemetryHelper implements IDisposable {
 	 */
 	public constructor(
 		private readonly eventBase: ITelemetryGenericEvent,
-		private readonly logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLoggerExt,
 		private readonly sampleThreshold: number,
 		private readonly includeAggregateMetrics: boolean = false,
 		private readonly perBucketProperties = new Map<string, ITelemetryProperties>(),

package/src/telemetryTypes.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryBaseLogger, TelemetryEventCategory } from "@fluidframework/common-definitions";
+import { ITelemetryBaseLogger, TelemetryEventCategory } from "@fluidframework/core-interfaces";
 
 /**
  * Property types that can be logged.
@@ -14,7 +14,11 @@ export type TelemetryEventPropertyTypeExt =
 	| number
 	| boolean
 	| undefined
-	| (string | number | boolean)[];
+	| (string | number | boolean)[]
+	| {
+			[key: string]: // Flat objects can have the same properties as the event itself
+			string | number | boolean | undefined | (string | number | boolean)[];
+	  };
 
 /**
  * A property to be logged to telemetry containing both the value and a tag. Tags are generic strings that can be used

package/src/thresholdCounter.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ITelemetryLoggerExt } from "./telemetryTypes";
 
 /**
  * Utility counter which will send event only if the provided value
@@ -12,7 +12,7 @@ import { ITelemetryLogger } from "@fluidframework/common-definitions";
 export class ThresholdCounter {
 	public constructor(
 		private readonly threshold: number,
-		private readonly logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLoggerExt,
 		private thresholdMultiple = threshold,
 	) {}
 

package/src/utils.ts

@@ -6,7 +6,7 @@ import {
 	ITelemetryBaseEvent,
 	ITelemetryBaseLogger,
 	ITelemetryGenericEvent,
-} from "@fluidframework/common-definitions";
+} from "@fluidframework/core-interfaces";
 
 /**
  * Like assert, but logs only if the condition is false, rather than throwing