@fluidframework/telemetry-utils 2.92.0 → 2.100.0

package/src/api.ts

@@ -0,0 +1,44 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// eslint-disable-next-line no-restricted-syntax
+export * from "./main.js";
+
+// Additional APIs that are deprecated and thus left out of the common export set.
+export type {
+	ITelemetryErrorEventExt,
+	ITelemetryGenericEventExt,
+	ITelemetryLoggerExt,
+	ITelemetryPerformanceEventExt,
+	TelemetryEventCategory,
+} from "./telemetryTypes.js";
+
+// ----------------------------------------------------------------------------
+// Export `createChildLogger` helper without internal `TelemetryLoggerExt`
+
+import type { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+
+import type { ITelemetryLoggerPropertyBags } from "./logger.js";
+import { createChildLogger as createChildLoggerInternal } from "./logger.js";
+import type { ITelemetryLoggerExt } from "./telemetryTypes.js";
+
+/**
+ * Create a child logger based on the provided props object.
+ *
+ * @remarks
+ * Passing in no props object (i.e. undefined) will return a logger that is effectively a no-op.
+ *
+ * @param props - logger is the base logger the child will log to after it's processing, namespace will be prefixed to all event names, properties are default properties that will be applied events.
+ *
+ * @legacy
+ * @beta
+ */
+export function createChildLogger(props?: {
+	logger?: ITelemetryBaseLogger;
+	namespace?: string;
+	properties?: ITelemetryLoggerPropertyBags;
+}): ITelemetryLoggerExt {
+	return createChildLoggerInternal(props);
+}

package/src/config.ts

@@ -11,7 +11,7 @@ import type {
 import { Lazy } from "@fluidframework/core-utils/internal";
 
 import { createChildLogger, tagCodeArtifacts } from "./logger.js";
-import type { ITelemetryLoggerExt } from "./telemetryTypes.js";
+import type { ITelemetryLoggerExt, TelemetryLoggerExt } from "./telemetryTypes.js";
 
 /**
  * Explicitly typed interface for reading configurations.
@@ -269,9 +269,13 @@ export class CachedConfigProvider implements IConfigProvider {
  *
  * @internal
  */
-export interface MonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt> {
+export interface MonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt> {
 	config: IConfigProvider;
-	logger: L;
+	// Since this is an internal context, assume that any external logger type
+	// (`ITelemetryLoggerExt`) is just the internal `TelemetryLoggerExt` type.
+	// `extractTelemetryLoggerExt` can be used to extract the internal type, but
+	// we'll just "cast" it here.
+	logger: L extends ITelemetryLoggerExt ? TelemetryLoggerExt : L;
 }
 
 /**
@@ -280,9 +284,9 @@ export interface MonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLo
  *
  * @internal
  */
-export function loggerIsMonitoringContext<
-	L extends ITelemetryBaseLogger = ITelemetryLoggerExt,
->(obj: L): obj is L & MonitoringContext<L> {
+export function loggerIsMonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt>(
+	obj: L,
+): obj is L & MonitoringContext<L> {
 	const maybeConfig = obj as Partial<MonitoringContext<L>> | undefined;
 	return isConfigProviderBase(maybeConfig?.config) && maybeConfig?.logger !== undefined;
 }
@@ -292,9 +296,9 @@ export function loggerIsMonitoringContext<
  *
  * @internal
  */
-export function loggerToMonitoringContext<
-	L extends ITelemetryBaseLogger = ITelemetryLoggerExt,
->(logger: L): MonitoringContext<L> {
+export function loggerToMonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt>(
+	logger: L,
+): MonitoringContext<L> {
 	if (loggerIsMonitoringContext<L>(logger)) {
 		return logger;
 	}
@@ -312,7 +316,7 @@ export function loggerToMonitoringContext<
  *
  * @internal
  */
-export function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(
+export function mixinMonitoringContext<L extends ITelemetryBaseLogger = TelemetryLoggerExt>(
 	logger: L,
 	...configs: (IConfigProviderBase | undefined)[]
 ): MonitoringContext<L> {
@@ -329,7 +333,9 @@ export function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemet
 	 */
 	const mc: L & Partial<MonitoringContext<L>> = logger;
 	mc.config = new CachedConfigProvider(logger, ...configs);
-	mc.logger = logger;
+	// Cast is similar to `extractTelemetryLoggerExt` but preserves other
+	// logger types rather than just returning `TelemetryLoggerExt`.
+	mc.logger = logger as L extends ITelemetryLoggerExt ? TelemetryLoggerExt : L;
 	return mc as MonitoringContext<L>;
 }
 

package/src/errorLogging.ts

@@ -10,7 +10,7 @@ import { v4 as uuid } from "uuid";
 import { type IFluidErrorBase, hasErrorInstanceId, isFluidError } from "./fluidErrorBase.js";
 import { convertToBasePropertyType } from "./logger.js";
 import type {
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	ITelemetryPropertiesExt,
 	TelemetryEventPropertyTypeExt,
 } from "./telemetryTypes.js";
@@ -286,7 +286,7 @@ export function wrapError<T extends LoggingError>(
 export function wrapErrorAndLog<T extends LoggingError>(
 	innerError: unknown,
 	newErrorFn: (message: string) => T,
-	logger: ITelemetryLoggerExt,
+	logger: TelemetryLoggerExt,
 ): T {
 	const newError = wrapError(innerError, newErrorFn);
 

package/src/events.ts

@@ -5,7 +5,7 @@
 
 import type { EventEmitter } from "@fluid-internal/client-utils";
 
-import type { ITelemetryLoggerExt } from "./telemetryTypes.js";
+import type { TelemetryLoggerExt } from "./telemetryTypes.js";
 
 /**
  * Note: The contents of this file really don't belong in this package, as they are only intended for internal use.
@@ -28,7 +28,7 @@ export const disconnectedEventName = "disconnected";
  */
 export function safeRaiseEvent(
 	emitter: EventEmitter,
-	logger: ITelemetryLoggerExt,
+	logger: TelemetryLoggerExt,
 	event: string,
 	...args: unknown[]
 ): void {
@@ -50,7 +50,7 @@ export function safeRaiseEvent(
  * @internal
  */
 export function raiseConnectedEvent(
-	logger: ITelemetryLoggerExt,
+	logger: TelemetryLoggerExt,
 	emitter: EventEmitter,
 	connected: boolean,
 	clientId?: string,

package/src/{index.ts → internal.ts}

@@ -3,6 +3,10 @@
  * Licensed under the MIT License.
  */
 
+// The "internal" exports are a superset of the standard ones. So, we want to export everything from the standard barrel file.
+// eslint-disable-next-line no-restricted-syntax
+export * from "./main.js";
+
 export {
 	createChildMonitoringContext,
 	type MonitoringContext,
@@ -40,7 +44,6 @@ export {
 	wrapError,
 	wrapErrorAndLog,
 } from "./errorLogging.js";
-export { EventEmitterWithErrorHandling } from "./eventEmitterWithErrorHandling.js";
 export {
 	connectedEventName,
 	disconnectedEventName,
@@ -57,10 +60,9 @@ export {
 	eventNamespaceSeparator,
 	createChildLogger,
 	createMultiSinkLogger,
+	extractTelemetryLoggerExt,
 	formatTick,
 	type IPerformanceEventMarkers,
-	type ITelemetryLoggerPropertyBag,
-	type ITelemetryLoggerPropertyBags,
 	type MultiSinkLoggerProperties,
 	numberFromString,
 	PerformanceEvent,
@@ -68,7 +70,7 @@ export {
 	tagData,
 	tagCodeArtifacts,
 	TelemetryDataTag,
-	type TelemetryEventPropertyTypes,
+	toITelemetryLoggerExt,
 } from "./logger.js";
 export {
 	createMockLoggerExt,
@@ -89,14 +91,27 @@ export {
 	measure,
 } from "./utils.js";
 export type {
-	TelemetryEventPropertyTypeExt,
 	ITelemetryEventExt,
+	TelemetryLoggerExt,
+} from "./telemetryTypes.js";
+export type {
 	ITelemetryGenericEventExt,
 	ITelemetryErrorEventExt,
 	ITelemetryPerformanceEventExt,
-	ITelemetryLoggerExt,
-	ITelemetryPropertiesExt,
 	TelemetryEventCategory,
-} from "./telemetryTypes.js";
+} from "./telemetryTypesUndeprecated.js";
 export { TelemetryEventBatcher } from "./telemetryEventBatcher.js";
 export { allowIncompatibleLayersKey, validateLayerCompatibility } from "./layerCompatError.js";
+
+import type { TelemetryLoggerExt } from "./telemetryTypes.js";
+
+/**
+ * Renamed version of TelemetryLoggerExt for convenience of internal use.
+ * Where "`ITelemetryLoggerExt`" is exposed in customer API surface, true
+ * `ITelemetryLoggerExt` (that is an erased type) must be used. To access
+ * use `@fluidframework/telemetry-utils/legacy` import spec. All internal
+ * usages should be promoted to `TelemetryLoggerExt` naming.
+ *
+ * @internal
+ */
+export type ITelemetryLoggerExt = TelemetryLoggerExt;

package/src/logger.ts

@@ -24,15 +24,55 @@ import {
 	isTaggedTelemetryPropertyValue,
 } from "./errorLogging.js";
 import type {
-	ITelemetryErrorEventExt,
 	ITelemetryEventExt,
-	ITelemetryGenericEventExt,
 	ITelemetryLoggerExt,
-	ITelemetryPerformanceEventExt,
 	ITelemetryPropertiesExt,
-	TelemetryEventCategory,
+	TelemetryLoggerExt,
 	TelemetryEventPropertyTypeExt,
 } from "./telemetryTypes.js";
+import type {
+	ITelemetryErrorEventExt,
+	ITelemetryGenericEventExt,
+	ITelemetryPerformanceEventExt,
+	TelemetryEventCategory,
+} from "./telemetryTypesUndeprecated.js";
+
+/**
+ * Type erase a {@link TelemetryLoggerExt} to an {@link ITelemetryLoggerExt}.
+ * @internal
+ */
+export function toITelemetryLoggerExt(logger: TelemetryLoggerExt): ITelemetryLoggerExt {
+	return logger as unknown as ITelemetryLoggerExt;
+}
+
+/**
+ * Un-type-erase the {@link ITelemetryLoggerExt}.
+ * @remarks
+ * This is the extraction helper as documented by {@link @fluidframework/core-interfaces#BrandedType}.
+ *
+ * @typeParam options - options for the extraction, currently only supports making
+ * the output possibly undefined (when `PossiblyUndefined: true`), which is useful
+ * for cases where we want to allow passing `undefined` through.
+ *
+ * @privateRemarks `ITelemetryLoggerExt` is not currently a branded type, but will
+ * be when the breaking change is made. At that time, use of this helper will be
+ * required.
+ *
+ * @internal
+ */
+export function extractTelemetryLoggerExt<
+	options extends {
+		PossiblyUndefined?: true;
+	} = // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- empty object without PossiblyUndefined is the correct type
+	{},
+>(
+	input:
+		| ITelemetryLoggerExt
+		| TelemetryLoggerExt
+		| (options["PossiblyUndefined"] extends true ? undefined : never),
+): TelemetryLoggerExt | (options["PossiblyUndefined"] extends true ? undefined : never) {
+	return input as unknown as TelemetryLoggerExt;
+}
 
 /**
  * Broad classifications to be applied to individual properties as they're prepared to be logged to telemetry.
@@ -70,6 +110,9 @@ export type ITelemetryLoggerPropertyBag = Record<
 /**
  * @legacy
  * @beta
+ *
+ * @privateRemarks
+ * This is exposed to support {@link createChildLogger} properties parameter.
  */
 export interface ITelemetryLoggerPropertyBags {
 	all?: ITelemetryLoggerPropertyBag;
@@ -115,7 +158,7 @@ export const eventNamespaceSeparator = ":";
  * encoding in one place schemas for various types of Fluid telemetry events.
  * Creates sub-logger that appends properties to all events
  */
-export abstract class TelemetryLogger implements ITelemetryLoggerExt {
+export abstract class TelemetryLogger implements TelemetryLoggerExt {
 	/**
 	 * {@inheritDoc eventNamespaceSeparator}
 	 */
@@ -361,6 +404,12 @@ export class TaggedLoggerAdapter implements ITelemetryBaseLogger {
 	}
 }
 
+function toEitherTelemetryLoggerExt(
+	logger: TelemetryLoggerExt,
+): TelemetryLoggerExt & ITelemetryLoggerExt {
+	return logger as TelemetryLoggerExt & ITelemetryLoggerExt;
+}
+
 /**
  * Create a child logger based on the provided props object.
  *
@@ -369,15 +418,25 @@ export class TaggedLoggerAdapter implements ITelemetryBaseLogger {
  *
  * @param props - logger is the base logger the child will log to after it's processing, namespace will be prefixed to all event names, properties are default properties that will be applied events.
  *
- * @legacy
- * @beta
+ * @internal
+ *
+ * @privateRemarks
+ * Return type is both TelemetryLoggerExt and ITelemetryLoggerExt to allow for
+ * easier internal usage without needing to type erase or un-type-erase the
+ * logger.
+ *
+ * If always creating a child logger for direct external exposure, consider
+ * using {@link createChildLogger} from /legacy API instead, which returns
+ * exactly an {@link ITelemetryLoggerExt}.
  */
 export function createChildLogger(props?: {
 	logger?: ITelemetryBaseLogger;
 	namespace?: string;
 	properties?: ITelemetryLoggerPropertyBags;
-}): ITelemetryLoggerExt {
-	return ChildLogger.create(props?.logger, props?.namespace, props?.properties);
+}): TelemetryLoggerExt & ITelemetryLoggerExt {
+	return toEitherTelemetryLoggerExt(
+		ChildLogger.create(props?.logger, props?.namespace, props?.properties),
+	);
 }
 
 /**
@@ -510,7 +569,7 @@ export interface MultiSinkLoggerProperties {
  *
  * @internal
  */
-export function createMultiSinkLogger(props: MultiSinkLoggerProperties): ITelemetryLoggerExt {
+export function createMultiSinkLogger(props: MultiSinkLoggerProperties): TelemetryLoggerExt {
 	return new MultiSinkLogger(
 		props.namespace,
 		props.properties,
@@ -636,12 +695,12 @@ export class PerformanceEvent {
 	 * @returns An instance of {@link PerformanceEvent}
 	 */
 	public static start(
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt | ITelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		markers?: IPerformanceEventMarkers,
 		emitLogs: boolean = true,
 	): PerformanceEvent {
-		return new PerformanceEvent(logger, event, markers, emitLogs);
+		return new PerformanceEvent(extractTelemetryLoggerExt(logger), event, markers, emitLogs);
 	}
 
 	/**
@@ -660,7 +719,7 @@ export class PerformanceEvent {
 	 * effectively "share" the sampling rate for the event.
 	 */
 	public static timedExec<T>(
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		callback: (event: PerformanceEvent) => T,
 		markers?: IPerformanceEventMarkers,
@@ -699,7 +758,7 @@ export class PerformanceEvent {
 	 * effectively "share" the sampling rate for the event.
 	 */
 	public static async timedExecAsync<T>(
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt | ITelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		callback: (event: PerformanceEvent) => Promise<T>,
 		markers?: IPerformanceEventMarkers,
@@ -730,7 +789,7 @@ export class PerformanceEvent {
 	private startMark?: string;
 
 	protected constructor(
-		private readonly logger: ITelemetryLoggerExt,
+		private readonly logger: TelemetryLoggerExt,
 		event: ITelemetryGenericEventExt,
 		private readonly markers: IPerformanceEventMarkers = { end: true, cancel: "generic" },
 		private readonly emitLogs: boolean = true,

package/src/main.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// This export set contains public APIs that don't have any special treatment
+// when exposed internally. APIs deprecated for external use but still needed
+// internally are re-exported from /internal with alternate tagging.
+
+export { EventEmitterWithErrorHandling } from "./eventEmitterWithErrorHandling.js";
+export type {
+	ITelemetryLoggerPropertyBag,
+	ITelemetryLoggerPropertyBags,
+	TelemetryEventPropertyTypes,
+} from "./logger.js";
+export type {
+	ITelemetryPropertiesExt,
+	TelemetryEventPropertyTypeExt,
+} from "./telemetryTypes.js";

package/src/mockLogger.ts

@@ -13,7 +13,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import { createChildLogger } from "./logger.js";
 import type {
 	ITelemetryEventExt,
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	ITelemetryPropertiesExt,
 } from "./telemetryTypes.js";
 
@@ -51,7 +51,7 @@ export class MockLogger implements ITelemetryBaseLogger {
 		this._events = [];
 	}
 
-	public toTelemetryLogger(): ITelemetryLoggerExt {
+	public toTelemetryLogger(): ReturnType<typeof createChildLogger> {
 		return createChildLogger({ logger: this });
 	}
 
@@ -357,13 +357,13 @@ function matchObjects(
 }
 
 /**
- * Mock {@link ITelemetryLoggerExt} implementation.
+ * Mock {@link TelemetryLoggerExt} implementation.
  *
  * @remarks Can be created via {@link createMockLoggerExt}.
  *
  * @internal
  */
-export interface IMockLoggerExt extends ITelemetryLoggerExt {
+export interface IMockLoggerExt extends TelemetryLoggerExt {
 	/**
 	 * Gets the events that have been logged so far.
 	 */

package/src/sampledTelemetryHelper.ts

@@ -10,9 +10,9 @@ import { assert } from "@fluidframework/core-utils/internal";
 import { roundToDecimalPlaces } from "./mathTools.js";
 import type {
 	ITelemetryGenericEventExt,
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	ITelemetryPerformanceEventExt,
-} from "./telemetryTypes.js";
+} from "./telemetryTypesUndeprecated.js";
 
 /**
  * @privateRemarks
@@ -163,7 +163,7 @@ export class SampledTelemetryHelper<
 	 */
 	public constructor(
 		private readonly eventBase: ITelemetryGenericEventExt,
-		private readonly logger: ITelemetryLoggerExt,
+		private readonly logger: TelemetryLoggerExt,
 		private readonly sampleThreshold: number,
 		private readonly includeAggregateMetrics: boolean = false,
 		private readonly perBucketProperties = new Map<string, ITelemetryBaseProperties>(),

package/src/telemetryEventBatcher.ts

@@ -6,9 +6,9 @@
 import { roundToDecimalPlaces } from "./mathTools.js";
 import type {
 	ITelemetryGenericEventExt,
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	ITelemetryPerformanceEventExt,
-} from "./telemetryTypes.js";
+} from "./telemetryTypesUndeprecated.js";
 
 /**
  * Telemetry class that accumulates measurements which are eventually logged in a telemetry event through the provided
@@ -46,7 +46,7 @@ export class TelemetryEventBatcher<TMetrics extends string> {
 		/**
 		 * The logger to use to write the telemetry performance event.
 		 */
-		private readonly logger: ITelemetryLoggerExt,
+		private readonly logger: TelemetryLoggerExt,
 
 		/**
 		 * The number of logs to accumulate before sending the data to the logger.

package/src/telemetryTypes.ts

@@ -13,6 +13,8 @@ import type { ITelemetryBaseLogger, LogLevel, Tagged } from "@fluidframework/cor
  * error - Error log event, ideally 0 of these are logged during a session
  *
  * performance - Includes duration, and often has _start, _end, or _cancel suffixes for activity tracking
+ * @deprecated This type is being removed without a replacement.
+ * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for details.
  * @legacy @beta
  */
 export type TelemetryEventCategory = "generic" | "error" | "performance";
@@ -65,6 +67,8 @@ export interface ITelemetryEventExt extends ITelemetryPropertiesExt {
 /**
  * Informational (non-error) telemetry event
  * @remarks Maps to category = "generic"
+ * @deprecated This type is being removed without a replacement.
+ * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for details.
  * @legacy @beta
  */
 export interface ITelemetryGenericEventExt extends ITelemetryPropertiesExt {
@@ -83,6 +87,8 @@ export interface ITelemetryGenericEventExt extends ITelemetryPropertiesExt {
 /**
  * Error telemetry event.
  * @remarks Maps to category = "error"
+ * @deprecated This type is being removed without a replacement.
+ * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for details.
  * @legacy @beta
  */
 export interface ITelemetryErrorEventExt extends ITelemetryPropertiesExt {
@@ -95,6 +101,8 @@ export interface ITelemetryErrorEventExt extends ITelemetryPropertiesExt {
 /**
  * Performance telemetry event.
  * @remarks Maps to category = "performance"
+ * @deprecated This type is being removed without a replacement.
+ * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for details.
  * @legacy @beta
  */
 export interface ITelemetryPerformanceEventExt extends ITelemetryGenericEventExt {
@@ -104,15 +112,73 @@ export interface ITelemetryPerformanceEventExt extends ITelemetryGenericEventExt
 	duration?: number;
 }
 
+/**
+ * This is the externally facing type for a FluidFramework internal telemetry logger wrapper.
+ *
+ * @remarks
+ * The methods if this interface are not to be used directly by consumers and are all
+ * deprecated to removed without replacement. This type is not deprecated and will
+ * transition to an erased type to handle cases where "internal" `ITelemetryLoggerExt`
+ * previously leaked out.
+ *
+ * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for deprecation and breaking change details.
+ *
+ * @privateRemarks
+ * External APIs taking in an `ITelemetryLoggerExt` ideally should be updated to
+ * accept `ITelemetryBaseLogger` instead.
+ *
+ * @sealed
+ * @legacy
+ * @beta
+ */
+export interface ITelemetryLoggerExt extends ITelemetryBaseLogger {
+	/**
+	 * Send an information telemetry event.
+	 * @param event - Event to send.
+	 * @param error - Optional error object to log.
+	 * @param logLevel - Optional level of the log. Default: {@link @fluidframework/core-interfaces#LogLevel.essential}.
+	 * @deprecated This method is being removed without a replacement.
+	 * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for details.
+	 */
+	sendTelemetryEvent(
+		event: ITelemetryGenericEventExt,
+		error?: unknown,
+		logLevel?: typeof LogLevel.verbose | typeof LogLevel.default,
+	): void;
+
+	/**
+	 * Send an error telemetry event.
+	 * @param event - Event to send.
+	 * @param error - Optional error object to log.
+	 * @deprecated This method is being removed without a replacement.
+	 * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for details.
+	 */
+	sendErrorEvent(event: ITelemetryErrorEventExt, error?: unknown): void;
+
+	/**
+	 * Send a performance telemetry event.
+	 * @param event - Event to send
+	 * @param error - Optional error object to log.
+	 * @param logLevel - Optional level of the log. Default: {@link @fluidframework/core-interfaces#LogLevel.essential}.
+	 * @deprecated This method is being removed without a replacement.
+	 * @see {@link https://github.com/microsoft/FluidFramework/issues/26910 | Issue #26910} for details.
+	 */
+	sendPerformanceEvent(
+		event: ITelemetryPerformanceEventExt,
+		error?: unknown,
+		logLevel?: typeof LogLevel.verbose | typeof LogLevel.default,
+	): void;
+}
+
 /**
  * An extended {@link @fluidframework/core-interfaces#ITelemetryBaseLogger} which allows for more lenient event types.
  *
  * @remarks
  * This interface is meant to be used internally within the Fluid Framework,
  * and `ITelemetryBaseLogger` should be used when loggers are passed between layers.
- * @legacy @beta
+ * @internal
  */
-export interface ITelemetryLoggerExt extends ITelemetryBaseLogger {
+export interface TelemetryLoggerExt extends ITelemetryBaseLogger {
 	/**
 	 * Send an information telemetry event.
 	 * @param event - Event to send.
@@ -136,7 +202,7 @@ export interface ITelemetryLoggerExt extends ITelemetryBaseLogger {
 	 * Send a performance telemetry event.
 	 * @param event - Event to send
 	 * @param error - Optional error object to log.
-	 * @param logLevel - Optional level of the log. Default: {@link @fluidframework/core-interfaces#LogLevel.default}.
+	 * @param logLevel - Optional level of the log. Default: {@link @fluidframework/core-interfaces#LogLevelConst.default | LogLevel.default}.
 	 */
 	sendPerformanceEvent(
 		event: ITelemetryPerformanceEventExt,

package/src/telemetryTypesUndeprecated.ts

@@ -0,0 +1,51 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/* eslint-disable import-x/no-deprecated -- This file specifically works with deprecated types to undeprecate them for internal use */
+
+// This file contains exports that "un-deprecate" certain types that we want to
+// continue using internally while exposing deprecated version that will be
+// removed in a future release.
+
+// For internal maintenance convenience, we re-export some non-deprecated types
+// from telemetryTypes.ts too.
+export type { TelemetryLoggerExt } from "./telemetryTypes.js";
+
+import type {
+	ITelemetryGenericEventExt as ExposedITelemetryGenericEventExt,
+	ITelemetryErrorEventExt as ExposedITelemetryErrorEventExt,
+	ITelemetryPerformanceEventExt as ExposedITelemetryPerformanceEventExt,
+	TelemetryEventCategory as ExposedTelemetryEventCategory,
+} from "./telemetryTypes.js";
+
+/**
+ * Informational (non-error) telemetry event
+ * @remarks Maps to category = "generic"
+ * @internal
+ */
+export type ITelemetryGenericEventExt = ExposedITelemetryGenericEventExt;
+/**
+ * Error telemetry event.
+ * @remarks Maps to category = "error"
+ * @internal
+ */
+export type ITelemetryErrorEventExt = ExposedITelemetryErrorEventExt;
+/**
+ * Performance telemetry event.
+ * @remarks Maps to category = "performance"
+ * @internal
+ */
+export type ITelemetryPerformanceEventExt = ExposedITelemetryPerformanceEventExt;
+/**
+ * The categories FF uses when instrumenting the code.
+ *
+ * generic - Informational log event
+ *
+ * error - Error log event, ideally 0 of these are logged during a session
+ *
+ * performance - Includes duration, and often has _start, _end, or _cancel suffixes for activity tracking
+ * @internal
+ */
+export type TelemetryEventCategory = ExposedTelemetryEventCategory;