@fluidframework/telemetry-utils 2.0.0-dev.7.4.0.215930 → 2.0.0-dev.7.4.0.217212

package/lib/telemetry-utils-alpha.d.ts

@@ -4,53 +4,24 @@ import { EventEmitter } from 'events';
 import { IDisposable } from '@fluidframework/core-interfaces';
 import { IErrorBase } from '@fluidframework/core-interfaces';
 import { IEvent } from '@fluidframework/core-interfaces';
-import { IGenericError } from '@fluidframework/core-interfaces';
-import { ILoggingError } from '@fluidframework/core-interfaces';
 import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
 import { ITelemetryBaseEvent } from '@fluidframework/core-interfaces';
 import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
 import { ITelemetryBaseProperties } from '@fluidframework/core-interfaces';
-import { ITelemetryErrorEvent } from '@fluidframework/core-interfaces';
-import { ITelemetryGenericEvent } from '@fluidframework/core-interfaces';
-import { ITelemetryPerformanceEvent } from '@fluidframework/core-interfaces';
 import { ITelemetryProperties } from '@fluidframework/core-interfaces';
-import { IUsageError } from '@fluidframework/core-interfaces';
-import { Lazy } from '@fluidframework/core-utils';
 import { LogLevel } from '@fluidframework/core-interfaces';
 import { Tagged } from '@fluidframework/core-interfaces';
-import { TelemetryBaseEventPropertyType } from '@fluidframework/core-interfaces';
 import { TelemetryEventPropertyType } from '@fluidframework/core-interfaces';
 
-export declare type ConfigTypes = string | number | boolean | number[] | string[] | boolean[] | undefined;
-
-export declare const connectedEventName = "connected";
-
-/**
- * Create a child logger based on the provided props object
- * @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.
- *
- * @remarks
- * Passing in no props object (i.e. undefined) will return a logger that is effectively a no-op.
- */
-export declare function createChildLogger(props?: {
-    logger?: ITelemetryBaseLogger;
-    namespace?: string;
-    properties?: ITelemetryLoggerPropertyBags;
-}): ITelemetryLoggerExt;
-
-export declare function createChildMonitoringContext(props: Parameters<typeof createChildLogger>[0]): MonitoringContext;
-
-/**
- * Create a logger which logs to multiple other loggers based on the provided props object
- * @param props - loggers are the base loggers that will logged to after it's processing, namespace will be prefixed to all event names, properties are default properties that will be applied events.
- * tryInheritProperties will attempted to copy those loggers properties to this loggers if they are of a known type e.g. one from this package
- */
-export declare function createMultiSinkLogger(props: {
-    namespace?: string;
-    properties?: ITelemetryLoggerPropertyBags;
-    loggers?: (ITelemetryBaseLogger | undefined)[];
-    tryInheritProperties?: true;
-}): ITelemetryLoggerExt;
+/* Excluded from this release type: ConfigTypes */
+
+/* Excluded from this release type: connectedEventName */
+
+/* Excluded from this release type: createChildLogger */
+
+/* Excluded from this release type: createChildMonitoringContext */
+
+/* Excluded from this release type: createMultiSinkLogger */
 
 /* Excluded from this release type: createSampledLogger */
 
@@ -58,40 +29,19 @@ export declare function createMultiSinkLogger(props: {
 
 /* Excluded from this release type: DataProcessingError */
 
-export declare const disconnectedEventName = "disconnected";
+/* Excluded from this release type: disconnectedEventName */
 
 /* Excluded from this release type: EventEmitterEventType */
 
-/**
- * Event Emitter helper class
- * Any exceptions thrown by listeners will be caught and raised through "error" event.
- * Any exception thrown by "error" listeners will propagate to the caller.
- */
-export declare class EventEmitterWithErrorHandling<TEvent extends IEvent = IEvent> extends TypedEventEmitter<TEvent> {
-    private readonly errorHandler;
-    constructor(errorHandler: (eventName: EventEmitterEventType, error: any) => void);
-    emit(event: EventEmitterEventType, ...args: unknown[]): boolean;
-}
+/* Excluded from this release type: EventEmitterWithErrorHandling */
 
-export declare const eventNamespaceSeparator: ":";
+/* Excluded from this release type: eventNamespaceSeparator */
 
 /* Excluded from this release type: extractLogSafeErrorProperties */
 
-/**
- * Extracts specific properties from the provided message that we know are safe to log.
- *
- * @param messageLike - Message to include info about via telemetry props.
- */
-export declare const extractSafePropertiesFromMessage: (messageLike: Partial<Pick<ISequencedDocumentMessage, "clientId" | "sequenceNumber" | "clientSequenceNumber" | "referenceSequenceNumber" | "minimumSequenceNumber" | "timestamp">>) => {
-    messageClientId: string | undefined;
-    messageSequenceNumber: number | undefined;
-    messageClientSequenceNumber: number | undefined;
-    messageReferenceSequenceNumber: number | undefined;
-    messageMinimumSequenceNumber: number | undefined;
-    messageTimestamp: number | undefined;
-};
-
-export declare function formatTick(tick: number): number;
+/* Excluded from this release type: extractSafePropertiesFromMessage */
+
+/* Excluded from this release type: formatTick */
 
 /* Excluded from this release type: generateErrorWithStack */
 
@@ -101,563 +51,117 @@ export declare function formatTick(tick: number): number;
 
 /* Excluded from this release type: getCircularReplacer */
 
-/**
- * Type guard for error data containing the {@link IFluidErrorBase.errorInstanceId} property.
- */
-export declare const hasErrorInstanceId: (x: unknown) => x is {
-    errorInstanceId: string;
-};
-
-/**
- * Explicitly typed interface for reading configurations
- */
-export declare interface IConfigProvider extends IConfigProviderBase {
-    getBoolean(name: string): boolean | undefined;
-    getNumber(name: string): number | undefined;
-    getString(name: string): string | undefined;
-    getBooleanArray(name: string): boolean[] | undefined;
-    getNumberArray(name: string): number[] | undefined;
-    getStringArray(name: string): string[] | undefined;
-}
-
-/**
- * Base interface for providing configurations to enable/disable/control features
- */
-export declare interface IConfigProviderBase {
-    getRawConfig(name: string): ConfigTypes;
-}
+/* Excluded from this release type: hasErrorInstanceId */
+
+/* Excluded from this release type: IConfigProvider */
+
+/* Excluded from this release type: IConfigProviderBase */
+
+/* Excluded from this release type: IConfigProviderBase_2 */
 
 /* Excluded from this release type: IEventSampler */
 
 /* Excluded from this release type: IFluidErrorAnnotations */
 
-/**
- * An error emitted by the Fluid Framework.
- *
- * @remarks
- *
- * All normalized errors flowing through the Fluid Framework adhere to this readonly interface.
- *
- * It features the members of {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error | Error}
- * made readonly, as well as  {@link IFluidErrorBase.errorType} and {@link IFluidErrorBase.errorInstanceId}.
- * It also features getters and setters for telemetry props to be included when the error is logged.
- */
-export declare interface IFluidErrorBase extends Error {
-    /**
-     * Classification of what type of error this is.
-     *
-     * @remarks Used programmatically by consumers to interpret the error.
-     */
-    readonly errorType: string;
-    /**
-     * Error's message property, made readonly.
-     *
-     * @remarks
-     *
-     * Recommendations:
-     *
-     * Be specific, but also take care when including variable data to consider suitability for aggregation in telemetry.
-     * Also avoid including any data that jeopardizes the user's privacy. Add a tagged telemetry property instead.
-     */
-    readonly message: string;
-    /**
-     * See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/stack}.
-     */
-    readonly stack?: string;
-    /**
-     * See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name}.
-     */
-    readonly name: string;
-    /**
-     * A Guid identifying this error instance.
-     *
-     * @remarks
-     *
-     * Useful in telemetry for deduplicating multiple logging events arising from the same error,
-     * or correlating an error with an inner error that caused it, in case of error wrapping.
-     */
-    readonly errorInstanceId: string;
-    /**
-     * Get the telemetry properties stashed on this error for logging.
-     */
-    getTelemetryProperties(): ITelemetryProperties;
-    /**
-     * Add telemetry properties to this error which will be logged with the error
-     */
-    addTelemetryProperties: (props: ITelemetryProperties) => void;
-}
-
-/**
- * Describes what events PerformanceEvent should log
- * By default, all events are logged, but client can override this behavior
- * For example, there is rarely a need to record start event, as we really after
- * success / failure tracking, including duration (on success).
- */
-export declare interface IPerformanceEventMarkers {
-    start?: true;
-    end?: true;
-    cancel?: "generic" | "error";
-}
+/* Excluded from this release type: IFluidErrorBase */
+
+/* Excluded from this release type: IGenericError */
+
+/* Excluded from this release type: ILoggingError */
+
+/* Excluded from this release type: IPerformanceEventMarkers */
 
 /* Excluded from this release type: ISampledTelemetryLogger */
 
 /* Excluded from this release type: isExternalError */
 
-/**
- * Type guard for {@link IFluidErrorBase}.
- */
-export declare function isFluidError(error: unknown): error is IFluidErrorBase;
-
-/**
- * type guard for ILoggingError interface
- */
-export declare const isILoggingError: (x: unknown) => x is ILoggingError;
-
-/**
- * Type guard to identify if a particular telemetry property appears to be a tagged telemetry property
- */
-export declare function isTaggedTelemetryPropertyValue(x: Tagged<TelemetryEventPropertyTypeExt> | TelemetryEventPropertyTypeExt): x is Tagged<TelemetryEventPropertyTypeExt>;
-
-/**
- * Type guard for old standard of valid/known errors.
- */
-export declare function isValidLegacyError(error: unknown): error is Omit<IFluidErrorBase, "errorInstanceId">;
-
-/**
- * A property to be logged to telemetry containing both the value and a tag. Tags are generic strings that can be used
- * to mark pieces of information that should be organized or handled differently by loggers in various first or third
- * party scenarios. For example, tags are used to mark personal information that should not be stored in logs.
- *
- * @deprecated Use Tagged<TelemetryEventPropertyTypeExt>
- */
-export declare interface ITaggedTelemetryPropertyTypeExt {
-    value: TelemetryEventPropertyTypeExt;
-    tag: string;
-}
-
-/**
- * Error telemetry event.
- * Maps to category = "error"
- */
-export declare interface ITelemetryErrorEventExt extends ITelemetryPropertiesExt {
-    eventName: string;
-}
-
-/**
- * Interface for logging telemetry statements.
- * Can contain any number of properties that get serialized as json payload.
- * @param category - category of the event, like "error", "performance", "generic", etc.
- * @param eventName - name of the event.
- */
-export declare interface ITelemetryEventExt extends ITelemetryPropertiesExt {
-    category: string;
-    eventName: string;
-}
-
-/**
- * Informational (non-error) telemetry event
- * Maps to category = "generic"
- */
-export declare interface ITelemetryGenericEventExt extends ITelemetryPropertiesExt {
-    eventName: string;
-    category?: TelemetryEventCategory;
-}
-
-/**
- * An extended TelemetryLogger interface which allows for more lenient event types.
- * This interface is meant to be used internally within the Fluid Framework,
- * and ITelemetryBaseLogger should be used when loggers are passed between layers.
- */
-export declare interface ITelemetryLoggerExt extends ITelemetryBaseLogger {
-    /**
-     * Send information telemetry event
-     * @param event - Event to send
-     * @param error - optional error object to log
-     * @param logLevel - optional level of the log.
-     */
-    sendTelemetryEvent(event: ITelemetryGenericEventExt, error?: unknown, logLevel?: typeof LogLevel.verbose | typeof LogLevel.default): void;
-    /**
-     * Send error telemetry event
-     * @param event - Event to send
-     * @param error - optional error object to log
-     */
-    sendErrorEvent(event: ITelemetryErrorEventExt, error?: unknown): void;
-    /**
-     * Send performance telemetry event
-     * @param event - Event to send
-     * @param error - optional error object to log
-     * @param logLevel - optional level of the log.
-     */
-    sendPerformanceEvent(event: ITelemetryPerformanceEventExt, error?: unknown, logLevel?: typeof LogLevel.verbose | typeof LogLevel.default): void;
-}
-
-export declare interface ITelemetryLoggerPropertyBag {
-    [index: string]: TelemetryEventPropertyTypes | (() => TelemetryEventPropertyTypes);
-}
-
-export declare interface ITelemetryLoggerPropertyBags {
-    all?: ITelemetryLoggerPropertyBag;
-    error?: ITelemetryLoggerPropertyBag;
-}
-
-/**
- * Performance telemetry event.
- * Maps to category = "performance"
- */
-export declare interface ITelemetryPerformanceEventExt extends ITelemetryGenericEventExt {
-    duration?: number;
-}
-
-/**
- * JSON-serializable properties, which will be logged with telemetry.
- */
-export declare interface ITelemetryPropertiesExt {
-    [index: string]: TelemetryEventPropertyTypeExt | Tagged<TelemetryEventPropertyTypeExt>;
-}
-
-export declare function loggerToMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(logger: L): MonitoringContext<L>;
+/* Excluded from this release type: isFluidError */
+
+/* Excluded from this release type: isILoggingError */
+
+/* Excluded from this release type: isTaggedTelemetryPropertyValue */
+
+/* Excluded from this release type: isValidLegacyError */
+
+/* Excluded from this release type: ITaggedTelemetryPropertyTypeExt */
+
+/* Excluded from this release type: ITelemetryErrorEvent */
+
+/* Excluded from this release type: ITelemetryErrorEventExt */
+
+/* Excluded from this release type: ITelemetryEventExt */
+
+/* Excluded from this release type: ITelemetryGenericEvent */
+
+/* Excluded from this release type: ITelemetryGenericEventExt */
+
+/* Excluded from this release type: ITelemetryLoggerExt */
+
+/* Excluded from this release type: ITelemetryLoggerPropertyBag */
+
+/* Excluded from this release type: ITelemetryLoggerPropertyBags */
+
+/* Excluded from this release type: ITelemetryPerformanceEvent */
+
+/* Excluded from this release type: ITelemetryPerformanceEventExt */
+
+/* Excluded from this release type: ITelemetryPropertiesExt */
+
+/* Excluded from this release type: IUsageError */
+
+/* Excluded from this release type: Lazy */
+
+/* Excluded from this release type: loggerToMonitoringContext */
 
 /* Excluded from this release type: LoggingError */
 
-/**
- * Like assert, but logs only if the condition is false, rather than throwing
- * @param condition - The condition to attest too
- * @param logger - The logger to log with
- * @param event - The string or event to log
- * @returns The outcome of the condition
- */
-export declare function logIfFalse(condition: unknown, logger: ITelemetryBaseLogger, event: string | ITelemetryGenericEvent): condition is true;
-
-export declare function mixinMonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt>(logger: L, ...configs: (IConfigProviderBase | undefined)[]): MonitoringContext<L>;
-
-/**
- * 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 declare class MockLogger implements ITelemetryBaseLogger {
-    readonly minLogLevel?: LogLevel | undefined;
-    events: ITelemetryBaseEvent[];
-    constructor(minLogLevel?: LogLevel | undefined);
-    clear(): void;
-    toTelemetryLogger(): ITelemetryLoggerExt;
-    send(event: ITelemetryBaseEvent): void;
-    /**
-     * Search events logged since the last time matchEvents was called, looking for the given expected
-     * events in order.
-     * @param expectedEvents - events in order that are expected to appear in the recorded log.
-     * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
-     * These event objects may be subsets of the logged events.
-     * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
-     */
-    matchEvents(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], inlineDetailsProp?: boolean): boolean;
-    /**
-     * Asserts that matchEvents is true, and prints the actual/expected output if not.
-     */
-    assertMatch(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], message?: string, inlineDetailsProp?: boolean): void;
-    /**
-     * Search events logged since the last time matchEvents was called, looking for any of the given
-     * expected events.
-     * @param expectedEvents - events that are expected to appear in the recorded log.
-     * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
-     * These event objects may be subsets of the logged events.
-     * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
-     * @returns if any of the expected events is found.
-     */
-    matchAnyEvent(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], inlineDetailsProp?: boolean): boolean;
-    /**
-     * Asserts that matchAnyEvent is true, and prints the actual/expected output if not.
-     */
-    assertMatchAny(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], message?: string, inlineDetailsProp?: boolean): void;
-    /**
-     * Search events logged since the last time matchEvents was called, looking only for the given expected
-     * events in order.
-     * @param expectedEvents - events in order that are expected to be the only events in the recorded log.
-     * @param inlineDetailsProp - true if the "details" property in the actual event should be extracted and inlined.
-     * These event objects may be subsets of the logged events.
-     * Note: category is omitted from the type because it's usually uninteresting and tedious to type.
-     */
-    matchEventStrict(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], inlineDetailsProp?: boolean): boolean;
-    /**
-     * Asserts that matchEvents is true, and prints the actual/expected output if not
-     */
-    assertMatchStrict(expectedEvents: Omit<ITelemetryBaseEvent, "category">[], message?: string, inlineDetailsProp?: boolean): void;
-    /**
-     * Asserts that matchAnyEvent is false for the given events, and prints the actual/expected output if not
-     */
-    assertMatchNone(disallowedEvents: Omit<ITelemetryBaseEvent, "category">[], message?: string, inlineDetailsProp?: boolean): void;
-    private getMatchedEventsCount;
-    /**
-     * Ensure the expected event is a strict subset of the actual event
-     */
-    private static eventsMatch;
-}
-
-/**
- * A type containing both a telemetry logger and a configuration provider
- */
-export declare interface MonitoringContext<L extends ITelemetryBaseLogger = ITelemetryLoggerExt> {
-    config: IConfigProvider;
-    logger: L;
-}
+/* Excluded from this release type: logIfFalse */
+
+/* Excluded from this release type: mixinMonitoringContext */
+
+/* Excluded from this release type: MockLogger */
+
+/* Excluded from this release type: MonitoringContext */
+
+/* Excluded from this release type: MultiSinkLoggerProperties */
 
 /* Excluded from this release type: NORMALIZED_ERROR_TYPE */
 
 /* Excluded from this release type: normalizeError */
 
-/**
- * Attempts to parse number from string.
- * If fails,returns original string.
- * Used to make telemetry data typed (and support math operations, like comparison),
- * in places where we do expect numbers (like contentsize/duration property in http header)
- */
-export declare function numberFromString(str: string | null | undefined): string | number | undefined;
+/* Excluded from this release type: numberFromString */
 
 /* Excluded from this release type: overwriteStack */
 
-/**
- * Helper class to log performance events
- */
-export declare class PerformanceEvent {
-    private readonly logger;
-    private readonly markers;
-    private readonly recordHeapSize;
-    private readonly emitLogs;
-    /**
-     * Creates an instance of {@link PerformanceEvent} and starts measurements
-     * @param logger - the logger to be used for publishing events
-     * @param event - the logging event details which will be published with the performance measurements
-     * @param markers - See {@link IPerformanceEventMarkers}
-     * @param recordHeapSize - whether or not to also record memory performance
-     * @param emitLogs - should this instance emit logs. If set to false, logs will not be emitted to the logger,
-     * but measurements will still be performed and any specified markers will be generated.
-     * @returns An instance of {@link PerformanceEvent}
-     */
-    static start(logger: ITelemetryLoggerExt, event: ITelemetryGenericEvent, markers?: IPerformanceEventMarkers, recordHeapSize?: boolean, emitLogs?: boolean): PerformanceEvent;
-    /**
-     * Measure a synchronous task
-     * @param logger - the logger to be used for publishing events
-     * @param event - the logging event details which will be published with the performance measurements
-     * @param callback - the task to be executed and measured
-     * @param markers - See {@link IPerformanceEventMarkers}
-     * @param sampleThreshold - events with the same name and category will be sent to the logger
-     * only when we hit this many executions of the task. If unspecified, all events will be sent.
-     * @returns The results of the executed task
-     *
-     * @remarks Note that if the "same" event (category + eventName) would be emitted by different
-     * tasks (`callback`), `sampleThreshold` is still applied only based on the event's category + eventName,
-     * so executing either of the tasks will increase the internal counter and they
-     * effectively "share" the sampling rate for the event.
-     */
-    static timedExec<T>(logger: ITelemetryLoggerExt, event: ITelemetryGenericEvent, callback: (event: PerformanceEvent) => T, markers?: IPerformanceEventMarkers, sampleThreshold?: number): T;
-    /**
-     * Measure an asynchronous task
-     * @param logger - the logger to be used for publishing events
-     * @param event - the logging event details which will be published with the performance measurements
-     * @param callback - the task to be executed and measured
-     * @param markers - See {@link IPerformanceEventMarkers}
-     * @param recordHeapSize - whether or not to also record memory performance
-     * @param sampleThreshold - events with the same name and category will be sent to the logger
-     * only when we hit this many executions of the task. If unspecified, all events will be sent.
-     * @returns The results of the executed task
-     *
-     * @remarks Note that if the "same" event (category + eventName) would be emitted by different
-     * tasks (`callback`), `sampleThreshold` is still applied only based on the event's category + eventName,
-     * so executing either of the tasks will increase the internal counter and they
-     * effectively "share" the sampling rate for the event.
-     */
-    static timedExecAsync<T>(logger: ITelemetryLoggerExt, event: ITelemetryGenericEvent, callback: (event: PerformanceEvent) => Promise<T>, markers?: IPerformanceEventMarkers, recordHeapSize?: boolean, sampleThreshold?: number): Promise<T>;
-    get duration(): number;
-    private event?;
-    private readonly startTime;
-    private startMark?;
-    private startMemoryCollection;
-    protected constructor(logger: ITelemetryLoggerExt, event: ITelemetryGenericEvent, markers?: IPerformanceEventMarkers, recordHeapSize?: boolean, emitLogs?: boolean);
-    reportProgress(props?: ITelemetryProperties, eventNameSuffix?: string): void;
-    private autoEnd;
-    end(props?: ITelemetryProperties): void;
-    private performanceEndMark;
-    cancel(props?: ITelemetryProperties, error?: unknown): void;
-    /**
-     * Report the event, if it hasn't already been reported.
-     */
-    reportEvent(eventNameSuffix: string, props?: ITelemetryProperties, error?: unknown): void;
-    private static readonly eventHits;
-    private static shouldReport;
-}
-
-/**
- * Raises events pertaining to the connection
- * @param logger - The logger to log telemetry
- * @param emitter - The event emitter instance
- * @param connected - A boolean tracking whether the connection was in a connected state or not
- * @param clientId - The connected/disconnected clientId
- * @param disconnectedReason - The reason for the connection to be disconnected (Used for telemetry purposes only)
- */
-export declare function raiseConnectedEvent(logger: ITelemetryLoggerExt, emitter: EventEmitter, connected: boolean, clientId?: string, disconnectedReason?: string): void;
-
-export declare function safeRaiseEvent(emitter: EventEmitter, logger: ITelemetryLoggerExt, event: string, ...args: unknown[]): void;
-
-/**
- * Helper class that executes a specified code block and writes an
- * {@link @fluidframework/core-interfaces#ITelemetryPerformanceEvent} to a specified logger every time a specified
- * number of executions is reached (or when the class is disposed). The `duration` field in the telemetry event is
- * the duration of the latest execution (sample) of the specified function. See the documentation of the
- * `includeAggregateMetrics` parameter for additional details that can be included.
- */
-export declare class SampledTelemetryHelper implements IDisposable {
-    private readonly eventBase;
-    private readonly logger;
-    private readonly sampleThreshold;
-    private readonly includeAggregateMetrics;
-    private readonly perBucketProperties;
-    disposed: boolean;
-    private readonly measurementsMap;
-    /**
-     * @param eventBase -
-     * Custom properties to include in the telemetry performance event when it is written.
-     * @param logger -
-     * The logger to use to write the telemetry performance event.
-     * @param sampleThreshold -
-     * Telemetry performance events will be generated every time we hit this many executions of the code block.
-     * @param includeAggregateMetrics -
-     * If set to `true`, the telemetry performance event will include aggregated metrics (total duration, min duration,
-     * max duration) for all the executions in between generated events.
-     * @param perBucketProperties -
-     * Map of strings that represent different buckets (which can be specified when calling the 'measure' method), to
-     * properties which should be added to the telemetry event for that bucket. If a bucket being measured does not
-     * have an entry in this map, no additional properties will be added to its telemetry events. The following keys are
-     * reserved for use by this class: "duration", "count", "totalDuration", "minDuration", "maxDuration". If any of
-     * them is specified as a key in one of the ITelemetryProperties objects in this map, that key-value pair will be
-     * ignored.
-     */
-    constructor(eventBase: ITelemetryGenericEvent, logger: ITelemetryLoggerExt, sampleThreshold: number, includeAggregateMetrics?: boolean, perBucketProperties?: Map<string, ITelemetryProperties>);
-    /**
-     * Executes the specified code and keeps track of execution time statistics.
-     * If it's been called enough times (the sampleThreshold for the class) then it generates a log message with the necessary information.
-     *
-     * @param codeToMeasure - The code to be executed and measured.
-     * @param bucket - A key to track executions of the code block separately.
-     * Each different value of this parameter has a separate set of executions and metrics tracked by the class.
-     * If no such distinction needs to be made, do not provide a value.
-     * @returns Whatever the passed-in code block returns.
-     */
-    measure<T>(codeToMeasure: () => T, bucket?: string): T;
-    private flushBucket;
-    dispose(error?: Error | undefined): void;
-}
-
-/**
- * Creates a base configuration provider based on `sessionStorage`
- *
- * @returns A lazy initialized base configuration provider with `sessionStorage` as the underlying config store
- */
-export declare const sessionStorageConfigProvider: Lazy<IConfigProviderBase>;
-
-/**
- * Helper function to tag telemetry properties as CodeArtifacts. It supports properties of type
- * TelemetryBaseEventPropertyType as well as getters that return TelemetryBaseEventPropertyType.
- */
-export declare const tagCodeArtifacts: <T extends Record<string, TelemetryEventPropertyType | (() => TelemetryBaseEventPropertyType)>>(values: T) => { [P in keyof T]: (T[P] extends () => TelemetryBaseEventPropertyType ? () => {
-        value: ReturnType<T[P]>;
-        tag: TelemetryDataTag.CodeArtifact;
-    } : {
-        value: Exclude<T[P], undefined>;
-        tag: TelemetryDataTag.CodeArtifact;
-    }) | (T[P] extends undefined ? undefined : never); };
-
-export declare const tagData: <T extends TelemetryDataTag, V extends Record<string, TelemetryEventPropertyType | (() => TelemetryBaseEventPropertyType)>>(tag: T, values: V) => { [P in keyof V]: (V[P] extends () => TelemetryBaseEventPropertyType ? () => {
-        value: ReturnType<V[P]>;
-        tag: T;
-    } : {
-        value: Exclude<V[P], undefined>;
-        tag: T;
-    }) | (V[P] extends undefined ? undefined : never); };
-
-/**
- * @deprecated 0.56, remove TaggedLoggerAdapter once its usage is removed from
- * container-runtime. Issue: #8191
- * TaggedLoggerAdapter class can add tag handling to your logger.
- */
-export declare class TaggedLoggerAdapter implements ITelemetryBaseLogger {
-    private readonly logger;
-    constructor(logger: ITelemetryBaseLogger);
-    /**
-     * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseLogger.send}
-     */
-    send(eventWithTagsMaybe: ITelemetryBaseEvent): void;
-}
-
-/**
- * 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.
- */
-export declare enum TelemetryDataTag {
-    /**
-     * Data containing terms or IDs from code packages that may have been dynamically loaded
-     */
-    CodeArtifact = "CodeArtifact",
-    /**
-     * Personal data of a variety of classifications that pertains to the user
-     */
-    UserData = "UserData"
-}
-
-/**
- * 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
- */
-export declare type TelemetryEventCategory = "generic" | "error" | "performance";
-
-/**
- * Property types that can be logged.
- * Includes extra types beyond TelemetryBaseEventPropertyType, which must be converted before sending to a base logger
- */
-export declare type TelemetryEventPropertyTypeExt = string | number | boolean | undefined | (string | number | boolean)[] | {
-    [key: string]: // Flat objects can have the same properties as the event itself
-    string | number | boolean | undefined | (string | number | boolean)[];
-};
-
-export declare type TelemetryEventPropertyTypes = ITelemetryBaseProperties[string];
-
-/**
- * Null logger that no-ops for all telemetry events passed to it.
- * @deprecated This will be removed in a future release.
- * For internal use within the FluidFramework codebase, use {@link createChildLogger} with no arguments instead.
- * For external consumers we recommend writing a trivial implementation of {@link @fluidframework/core-interfaces#ITelemetryBaseLogger}
- * where the send() method does nothing and using that.
- */
-export declare class TelemetryNullLogger implements ITelemetryLoggerExt {
-    send(event: ITelemetryBaseEvent): void;
-    sendTelemetryEvent(event: ITelemetryGenericEvent, error?: unknown): void;
-    sendErrorEvent(event: ITelemetryErrorEvent, error?: unknown): void;
-    sendPerformanceEvent(event: ITelemetryPerformanceEvent, error?: unknown): void;
-}
-
-/**
- * Utility counter which will send event only if the provided value
- * is above a configured threshold
- */
-export declare class ThresholdCounter {
-    private readonly threshold;
-    private readonly logger;
-    private thresholdMultiple;
-    constructor(threshold: number, logger: ITelemetryLoggerExt, thresholdMultiple?: number);
-    /**
-     * Sends the value if it's above the treshold.
-     */
-    send(eventName: string, value: number): void;
-    /**
-     * Sends the value if it's above the threshold
-     * and a multiple of the threshold.
-     *
-     * To be used in scenarios where we'd like to record a
-     * threshold violation while reducing telemetry noise.
-     */
-    sendIfMultiple(eventName: string, value: number): void;
-}
+/* Excluded from this release type: PerformanceEvent */
+
+/* Excluded from this release type: raiseConnectedEvent */
+
+/* Excluded from this release type: safeRaiseEvent */
+
+/* Excluded from this release type: SampledTelemetryHelper */
+
+/* Excluded from this release type: sessionStorageConfigProvider */
+
+/* Excluded from this release type: tagCodeArtifacts */
+
+/* Excluded from this release type: tagData */
+
+/* Excluded from this release type: TaggedLoggerAdapter */
+
+/* Excluded from this release type: TelemetryBaseEventPropertyType */
+
+/* Excluded from this release type: TelemetryDataTag */
+
+/* Excluded from this release type: TelemetryEventCategory */
+
+/* Excluded from this release type: TelemetryEventPropertyTypeExt */
+
+/* Excluded from this release type: TelemetryEventPropertyTypes */
+
+/* Excluded from this release type: TelemetryNullLogger */
+
+/* Excluded from this release type: ThresholdCounter */
 
 /* Excluded from this release type: TypedEventEmitter */