@fluidframework/telemetry-utils 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/lib/logger.js

@@ -2,51 +2,65 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { BaseTelemetryNullLogger, performance } from "@fluidframework/common-utils";
-import { CachedConfigProvider, loggerIsMonitoringContext, mixinMonitoringContext, } from "./config";
-import { isILoggingError, extractLogSafeErrorProperties, generateStack, } from "./errorLogging";
+import { LogLevel, } from "@fluidframework/core-interfaces";
+import { performance } from "@fluid-internal/client-utils";
+import { CachedConfigProvider, loggerIsMonitoringContext, mixinMonitoringContext } from "./config";
+import { isILoggingError, extractLogSafeErrorProperties, generateStack, isTaggedTelemetryPropertyValue, } from "./errorLogging";
 /**
  * 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.
+ *
+ * @privateRemarks Please do not modify existing entries, to maintain backwards compatibility.
+ *
+ * @internal
  */
 export var TelemetryDataTag;
 (function (TelemetryDataTag) {
     /**
-     * Data containing terms from code packages that may have been dynamically loaded
-     * @deprecated 1.0, will be removed in next release (see issue #6603). Use `TelemetryDataTag.CodeArtifact` instead.
+     * Data containing terms or IDs from code packages that may have been dynamically loaded
      */
-    TelemetryDataTag["PackageData"] = "PackageData";
-    /** Data containing terms or IDs from code packages that may have been dynamically loaded */
     TelemetryDataTag["CodeArtifact"] = "CodeArtifact";
-    /** Personal data of a variety of classifications that pertains to the user */
+    /**
+     * Personal data of a variety of classifications that pertains to the user
+     */
     TelemetryDataTag["UserData"] = "UserData";
 })(TelemetryDataTag || (TelemetryDataTag = {}));
+/**
+ * Attempts to parse number from string.
+ * If it fails, it will return the original string.
+ *
+ * @remarks
+ * 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).
+ *
+ * @internal
+ */
+// eslint-disable-next-line @rushstack/no-new-null
+export function numberFromString(str) {
+    if (str === undefined || str === null) {
+        return undefined;
+    }
+    const num = Number(str);
+    return Number.isNaN(num) ? str : num;
+}
+// TODO: add docs
+// eslint-disable-next-line jsdoc/require-description
+/**
+ * @internal
+ */
+export function formatTick(tick) {
+    return Math.floor(tick);
+}
+/**
+ * String used to concatenate the namespace of parent loggers and their child loggers.
+ * @internal
+ */
+export const eventNamespaceSeparator = ":";
 /**
  * TelemetryLogger class contains various helper telemetry methods,
  * encoding in one place schemas for various types of Fluid telemetry events.
  * Creates sub-logger that appends properties to all events
  */
 export class TelemetryLogger {
-    constructor(namespace, properties) {
-        this.namespace = namespace;
-        this.properties = properties;
-    }
-    static formatTick(tick) {
-        return Math.floor(tick);
-    }
-    /**
-     * 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)
-     */
-    static numberFromString(str) {
-        if (str === undefined || str === null) {
-            return undefined;
-        }
-        const num = Number(str);
-        return Number.isNaN(num) ? str : num;
-    }
     static sanitizePkgName(name) {
         return name.replace("@", "").replace("/", "-");
     }
@@ -79,32 +93,38 @@ export class TelemetryLogger {
             event.stack = generateStack();
         }
     }
+    constructor(namespace, properties) {
+        this.namespace = namespace;
+        this.properties = properties;
+    }
     /**
      * Send a telemetry event with the logger
      *
      * @param event - the event to send
      * @param error - optional error object to log
+     * @param logLevel - optional level of the log. It category of event is set as error,
+     * then the logLevel will be upgraded to be an error.
      */
-    sendTelemetryEvent(event, error) {
-        var _a;
-        this.sendTelemetryEventCore(Object.assign(Object.assign({}, event), { category: (_a = event.category) !== null && _a !== void 0 ? _a : "generic" }), error);
+    sendTelemetryEvent(event, error, logLevel = LogLevel.default) {
+        this.sendTelemetryEventCore({ ...event, category: event.category ?? "generic" }, error, event.category === "error" ? LogLevel.error : logLevel);
     }
     /**
      * Send a telemetry event with the logger
      *
      * @param event - the event to send
      * @param error - optional error object to log
+     * @param logLevel - optional level of the log.
      */
-    sendTelemetryEventCore(event, error) {
-        const newEvent = Object.assign({}, event);
+    sendTelemetryEventCore(event, error, logLevel) {
+        const newEvent = convertToBaseEvent(event);
         if (error !== undefined) {
             TelemetryLogger.prepareErrorObject(newEvent, error, false);
         }
         // Will include Nan & Infinity, but probably we do not care
         if (typeof newEvent.duration === "number") {
-            newEvent.duration = TelemetryLogger.formatTick(newEvent.duration);
+            newEvent.duration = formatTick(newEvent.duration);
         }
-        this.send(newEvent);
+        this.send(newEvent, logLevel);
     }
     /**
      * Send an error telemetry event with the logger
@@ -113,28 +133,41 @@ export class TelemetryLogger {
      * @param error - optional error object to log
      */
     sendErrorEvent(event, error) {
-        this.sendTelemetryEventCore(Object.assign(Object.assign({ 
+        this.sendTelemetryEventCore({
             // ensure the error field has some value,
             // this can and will be overridden by event, or error
-            error: event.eventName }, event), { category: "error" }), error);
+            error: event.eventName,
+            ...event,
+            category: "error",
+        }, error, LogLevel.error);
     }
     /**
      * Send a performance telemetry event with the logger
      *
      * @param event - Event to send
      * @param error - optional error object to log
+     * @param logLevel - optional level of the log. It category of event is set as error,
+     * then the logLevel will be upgraded to be an error.
      */
-    sendPerformanceEvent(event, error) {
-        var _a;
-        const perfEvent = Object.assign(Object.assign({}, event), { category: (_a = event.category) !== null && _a !== void 0 ? _a : "performance" });
-        this.sendTelemetryEventCore(perfEvent, error);
+    sendPerformanceEvent(event, error, logLevel = LogLevel.default) {
+        const perfEvent = {
+            ...event,
+            category: event.category ?? "performance",
+        };
+        this.sendTelemetryEventCore(perfEvent, error, perfEvent.category === "error" ? LogLevel.error : logLevel);
     }
     prepareEvent(event) {
         const includeErrorProps = event.category === "error" || event.error !== undefined;
-        const newEvent = Object.assign({}, event);
+        const newEvent = {
+            ...event,
+        };
         if (this.namespace !== undefined) {
             newEvent.eventName = `${this.namespace}${TelemetryLogger.eventNamespaceSeparator}${newEvent.eventName}`;
         }
+        return this.extendProperties(newEvent, includeErrorProps);
+    }
+    extendProperties(toExtend, includeErrorProps) {
+        const eventLike = toExtend;
         if (this.properties) {
             const properties = [];
             properties.push(this.properties.all);
@@ -144,32 +177,40 @@ export class TelemetryLogger {
             for (const props of properties) {
                 if (props !== undefined) {
                     for (const key of Object.keys(props)) {
-                        if (event[key] !== undefined) {
+                        if (eventLike[key] !== undefined) {
                             continue;
                         }
                         const getterOrValue = props[key];
                         // If this throws, hopefully it is handled elsewhere
                         const value = typeof getterOrValue === "function" ? getterOrValue() : getterOrValue;
                         if (value !== undefined) {
-                            newEvent[key] = value;
+                            eventLike[key] = value;
                         }
                     }
                 }
             }
         }
-        return newEvent;
+        return toExtend;
     }
 }
-TelemetryLogger.eventNamespaceSeparator = ":";
+/**
+ * {@inheritDoc eventNamespaceSeparator}
+ */
+TelemetryLogger.eventNamespaceSeparator = eventNamespaceSeparator;
 /**
  * @deprecated 0.56, remove TaggedLoggerAdapter once its usage is removed from
  * container-runtime. Issue: #8191
  * TaggedLoggerAdapter class can add tag handling to your logger.
+ *
+ * @internal
  */
 export class TaggedLoggerAdapter {
     constructor(logger) {
         this.logger = logger;
     }
+    /**
+     * {@inheritDoc @fluidframework/core-interfaces#ITelemetryBaseLogger.send}
+     */
     send(eventWithTagsMaybe) {
         const newEvent = {
             category: eventWithTagsMaybe.category,
@@ -177,55 +218,64 @@ export class TaggedLoggerAdapter {
         };
         for (const key of Object.keys(eventWithTagsMaybe)) {
             const taggableProp = eventWithTagsMaybe[key];
-            const { value, tag } = (typeof taggableProp === "object")
+            const { value, tag } = typeof taggableProp === "object"
                 ? taggableProp
                 : { value: taggableProp, tag: undefined };
             switch (tag) {
-                case undefined:
+                case undefined: {
                     // No tag means we can log plainly
                     newEvent[key] = value;
                     break;
-                case TelemetryDataTag.PackageData:
-                    // For Microsoft applications, PackageData is safe for now
+                }
+                case "PackageData": // For back-compat
+                case TelemetryDataTag.CodeArtifact: {
+                    // For Microsoft applications, CodeArtifact is safe for now
                     // (we don't load 3P code in 1P apps)
                     newEvent[key] = value;
                     break;
-                case TelemetryDataTag.UserData:
-                    // Strip out anything tagged explicitly as PII.
+                }
+                case TelemetryDataTag.UserData: {
+                    // Strip out anything tagged explicitly as UserData.
                     // Alternate strategy would be to hash these props
                     newEvent[key] = "REDACTED (UserData)";
                     break;
-                default:
+                }
+                default: {
                     // If we encounter a tag we don't recognize
                     // then we must assume we should scrub.
                     newEvent[key] = "REDACTED (unknown tag)";
                     break;
+                }
             }
         }
         this.logger.send(newEvent);
     }
 }
+/**
+ * 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.
+ *
+ * @alpha
+ */
+export function createChildLogger(props) {
+    return ChildLogger.create(props?.logger, props?.namespace, props?.properties);
+}
 /**
  * ChildLogger class contains various helper telemetry methods,
  * encoding in one place schemas for various types of Fluid telemetry events.
- * Creates sub-logger that appends properties to all events
+ * Creates sub-logger that appends properties to all events.
  */
 export class ChildLogger extends TelemetryLogger {
-    constructor(baseLogger, namespace, properties) {
-        super(namespace, properties);
-        this.baseLogger = baseLogger;
-        // propagate the monitoring context
-        if (loggerIsMonitoringContext(baseLogger)) {
-            mixinMonitoringContext(this, new CachedConfigProvider(baseLogger.config));
-        }
-    }
     /**
      * Create child logger
      * @param baseLogger - Base logger to use to output events. If undefined, proper child logger
-     * is created, but it does not sends telemetry events anywhere.
+     * 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
      */
     static create(baseLogger, namespace, properties) {
         // if we are creating a child of a child, rather than nest, which will increase
@@ -235,10 +285,16 @@ export class ChildLogger extends TelemetryLogger {
             for (const extendedProps of [baseLogger.properties, properties]) {
                 if (extendedProps !== undefined) {
                     if (extendedProps.all !== undefined) {
-                        combinedProperties.all = Object.assign(Object.assign({}, combinedProperties.all), extendedProps.all);
+                        combinedProperties.all = {
+                            ...combinedProperties.all,
+                            ...extendedProps.all,
+                        };
                     }
                     if (extendedProps.error !== undefined) {
-                        combinedProperties.error = Object.assign(Object.assign({}, combinedProperties.error), extendedProps.error);
+                        combinedProperties.error = {
+                            ...combinedProperties.error,
+                            ...extendedProps.error,
+                        };
                     }
                 }
             }
@@ -247,34 +303,95 @@ export class ChildLogger extends TelemetryLogger {
                 : namespace === undefined
                     ? baseLogger.namespace
                     : `${baseLogger.namespace}${TelemetryLogger.eventNamespaceSeparator}${namespace}`;
-            return new ChildLogger(baseLogger.baseLogger, combinedNamespace, combinedProperties);
+            const child = new ChildLogger(baseLogger.baseLogger, combinedNamespace, combinedProperties);
+            if (!loggerIsMonitoringContext(child) && loggerIsMonitoringContext(baseLogger)) {
+                mixinMonitoringContext(child, baseLogger.config);
+            }
+            return child;
+        }
+        return new ChildLogger(baseLogger ?? { send() { } }, namespace, properties);
+    }
+    constructor(baseLogger, namespace, properties) {
+        super(namespace, properties);
+        this.baseLogger = baseLogger;
+        // propagate the monitoring context
+        if (loggerIsMonitoringContext(baseLogger)) {
+            mixinMonitoringContext(this, new CachedConfigProvider(this, baseLogger.config));
         }
-        return new ChildLogger(baseLogger ? baseLogger : new BaseTelemetryNullLogger(), namespace, properties);
+    }
+    get minLogLevel() {
+        return this.baseLogger.minLogLevel;
+    }
+    shouldFilterOutEvent(event, logLevel) {
+        const eventLogLevel = logLevel ?? LogLevel.default;
+        const configLogLevel = this.baseLogger.minLogLevel ?? LogLevel.default;
+        // Filter out in case event log level is below what is wanted in config.
+        return eventLogLevel < configLogLevel;
     }
     /**
      * Send an event with the logger
      *
      * @param event - the event to send
      */
-    send(event) {
-        this.baseLogger.send(this.prepareEvent(event));
+    send(event, logLevel) {
+        if (this.shouldFilterOutEvent(event, logLevel)) {
+            return;
+        }
+        this.baseLogger.send(this.prepareEvent(event), logLevel);
     }
 }
+/**
+ * Create a logger which logs to multiple other loggers based on the provided props object.
+ *
+ * @internal
+ */
+export function createMultiSinkLogger(props) {
+    return new MultiSinkLogger(props.namespace, props.properties, props.loggers?.filter((l) => l !== undefined), props.tryInheritProperties);
+}
 /**
  * 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 {
     /**
      * 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
+     * @param loggers - The list of loggers to use as sinks
+     * @param tryInheritProperties - Will attempted to copy those loggers properties to this loggers if they are of a known type e.g. one from this package
      */
-    constructor(namespace, properties) {
-        super(namespace, properties);
-        this.loggers = [];
+    constructor(namespace, properties, loggers = [], tryInheritProperties) {
+        let realProperties = properties === undefined ? undefined : { ...properties };
+        if (tryInheritProperties === true) {
+            const merge = (realProperties ?? (realProperties = {}));
+            loggers
+                .filter((l) => l instanceof TelemetryLogger)
+                .map((l) => l.properties ?? {})
+                // eslint-disable-next-line unicorn/no-array-for-each
+                .forEach((cv) => {
+                // eslint-disable-next-line unicorn/no-array-for-each
+                Object.keys(cv).forEach((k) => {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    merge[k] = { ...cv[k], ...merge?.[k] };
+                });
+            });
+        }
+        super(namespace, realProperties);
+        this.loggers = loggers;
+        this._minLogLevelOfAllLoggers = LogLevel.default;
+        this.calculateMinLogLevel();
+    }
+    get minLogLevel() {
+        return this._minLogLevelOfAllLoggers;
+    }
+    calculateMinLogLevel() {
+        if (this.loggers.length > 0) {
+            const logLevels = [];
+            for (const logger of this.loggers) {
+                logLevels.push(logger.minLogLevel ?? LogLevel.default);
+            }
+            this._minLogLevelOfAllLoggers = Math.min(...logLevels);
+        }
     }
     /**
      * Add logger to send all events to
@@ -283,6 +400,8 @@ export class MultiSinkLogger extends TelemetryLogger {
     addLogger(logger) {
         if (logger !== undefined && logger !== null) {
             this.loggers.push(logger);
+            // Update in case the logLevel of added logger is less than the current.
+            this.calculateMinLogLevel();
         }
     }
     /**
@@ -292,33 +411,48 @@ export class MultiSinkLogger extends TelemetryLogger {
      */
     send(event) {
         const newEvent = this.prepareEvent(event);
-        this.loggers.forEach((logger) => {
+        for (const logger of this.loggers) {
             logger.send(newEvent);
-        });
+        }
     }
 }
 /**
- * Helper class to log performance events
+ * Helper class to log performance events.
+ *
+ * @internal
  */
 export class PerformanceEvent {
-    constructor(logger, event, markers = { end: true, cancel: "generic" }) {
-        this.logger = logger;
-        this.markers = markers;
-        this.startTime = performance.now();
-        this.event = Object.assign({}, event);
-        if (this.markers.start) {
-            this.reportEvent("start");
-        }
-        if (typeof window === "object" && window != null && window.performance) {
-            this.startMark = `${event.eventName}-start`;
-            window.performance.mark(this.startMark);
-        }
-    }
-    static start(logger, event, markers) {
-        return new PerformanceEvent(logger, event, markers);
+    /**
+     * 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, event, markers, recordHeapSize = false, emitLogs = true) {
+        return new PerformanceEvent(logger, event, markers, recordHeapSize, emitLogs);
     }
-    static timedExec(logger, event, callback, markers) {
-        const perfEvent = PerformanceEvent.start(logger, event, markers);
+    /**
+     * 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(logger, event, callback, markers, sampleThreshold = 1) {
+        const perfEvent = PerformanceEvent.start(logger, event, markers, undefined, // recordHeapSize
+        PerformanceEvent.shouldReport(event, sampleThreshold));
         try {
             const ret = callback(perfEvent);
             perfEvent.autoEnd();
@@ -329,8 +463,24 @@ export class PerformanceEvent {
             throw error;
         }
     }
-    static async timedExecAsync(logger, event, callback, markers) {
-        const perfEvent = PerformanceEvent.start(logger, event, markers);
+    /**
+     * 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 async timedExecAsync(logger, event, callback, markers, recordHeapSize, sampleThreshold = 1) {
+        const perfEvent = PerformanceEvent.start(logger, event, markers, recordHeapSize, PerformanceEvent.shouldReport(event, sampleThreshold));
         try {
             const ret = await callback(perfEvent);
             perfEvent.autoEnd();
@@ -341,7 +491,25 @@ export class PerformanceEvent {
             throw error;
         }
     }
-    get duration() { return performance.now() - this.startTime; }
+    get duration() {
+        return performance.now() - this.startTime;
+    }
+    constructor(logger, event, markers = { end: true, cancel: "generic" }, recordHeapSize = false, emitLogs = true) {
+        this.logger = logger;
+        this.markers = markers;
+        this.recordHeapSize = recordHeapSize;
+        this.emitLogs = emitLogs;
+        this.startTime = performance.now();
+        this.startMemoryCollection = 0;
+        this.event = { ...event };
+        if (this.markers.start) {
+            this.reportEvent("start");
+        }
+        if (typeof window === "object" && window?.performance?.mark) {
+            this.startMark = `${event.eventName}-start`;
+            window.performance.mark(this.startMark);
+        }
+    }
     reportProgress(props, eventNameSuffix = "update") {
         this.reportEvent(eventNameSuffix, props);
     }
@@ -368,7 +536,7 @@ export class PerformanceEvent {
     }
     cancel(props, error) {
         if (this.markers.cancel !== undefined) {
-            this.reportEvent("cancel", Object.assign({ category: this.markers.cancel }, props), error);
+            this.reportEvent("cancel", { category: this.markers.cancel, ...props }, error);
         }
         this.event = undefined;
     }
@@ -382,48 +550,164 @@ export class PerformanceEvent {
         if (!this.event) {
             return;
         }
-        const event = Object.assign(Object.assign({}, this.event), props);
+        if (!this.emitLogs) {
+            return;
+        }
+        const event = { ...this.event, ...props };
         event.eventName = `${event.eventName}_${eventNameSuffix}`;
         if (eventNameSuffix !== "start") {
             event.duration = this.duration;
+            if (this.startMemoryCollection) {
+                const currentMemory = performance?.memory
+                    ?.usedJSHeapSize;
+                const differenceInKBytes = Math.floor((currentMemory - this.startMemoryCollection) / 1024);
+                if (differenceInKBytes > 0) {
+                    event.usedJSHeapSize = differenceInKBytes;
+                }
+            }
+        }
+        else if (this.recordHeapSize) {
+            this.startMemoryCollection = performance?.memory
+                ?.usedJSHeapSize;
         }
         this.logger.sendPerformanceEvent(event, error);
     }
+    static shouldReport(event, sampleThreshold) {
+        const eventKey = `.${event.category}.${event.eventName}`;
+        const hitCount = PerformanceEvent.eventHits.get(eventKey) ?? 0;
+        PerformanceEvent.eventHits.set(eventKey, hitCount >= sampleThreshold ? 1 : hitCount + 1);
+        return hitCount % sampleThreshold === 0;
+    }
 }
+PerformanceEvent.eventHits = new Map();
 /**
- * Logger that is useful for UT
- * It can be used in places where logger instance is required, but events should be not send over.
+ * 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.
+ *
+ * @internal
  */
-export class TelemetryUTLogger {
-    send(event) {
-    }
-    sendTelemetryEvent(event, error) {
-    }
-    sendErrorEvent(event, error) {
-        this.reportError("errorEvent in UT logger!", event, error);
-    }
-    sendPerformanceEvent(event, error) {
-    }
-    logGenericError(eventName, error) {
-        this.reportError(`genericError in UT logger!`, { eventName }, error);
-    }
-    logException(event, exception) {
-        this.reportError("exception in UT logger!", event, exception);
+export class TelemetryNullLogger {
+    send(event) { }
+    sendTelemetryEvent(event, error) { }
+    sendErrorEvent(event, error) { }
+    sendPerformanceEvent(event, error) { }
+}
+/**
+ * Takes in an event object, and converts all of its values to a basePropertyType.
+ * In the case of an invalid property type, the value will be converted to an error string.
+ * @param event - Event with fields you want to stringify.
+ */
+function convertToBaseEvent({ category, eventName, ...props }) {
+    const newEvent = { category, eventName };
+    for (const key of Object.keys(props)) {
+        newEvent[key] = convertToBasePropertyType(props[key]);
     }
-    debugAssert(condition, event) {
-        this.reportError("debugAssert in UT logger!");
+    return newEvent;
+}
+/**
+ * Takes in value, and does one of 4 things.
+ * if value is of primitive type - returns the original value.
+ * If the value is a flat array or object - returns a stringified version of the array/object.
+ * If the value is an object of type Tagged<TelemetryEventPropertyType> - returns the object
+ * with its values recursively converted to base property Type.
+ * If none of these cases are reached - returns an error string
+ * @param x - value passed in to convert to a base property type
+ */
+export function convertToBasePropertyType(x) {
+    return isTaggedTelemetryPropertyValue(x)
+        ? {
+            value: convertToBasePropertyTypeUntagged(x.value),
+            tag: x.tag,
+        }
+        : convertToBasePropertyTypeUntagged(x);
+}
+function convertToBasePropertyTypeUntagged(x) {
+    switch (typeof x) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "undefined": {
+            return x;
+        }
+        case "object": {
+            // 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
+            console.error(`convertToBasePropertyTypeUntagged: INVALID PROPERTY (typed as ${typeof x})`);
+            return `INVALID PROPERTY (typed as ${typeof x})`;
+        }
     }
-    shipAssert(condition, event) {
-        this.reportError("shipAssert in UT logger!");
+}
+/**
+ * Tags all given `values` with the same `tag`.
+ *
+ * @param tag - The tag with which all `values` will be annotated.
+ * @param values - The values to be tagged.
+ *
+ * @remarks
+ * It supports properties of type {@link @fluidframework/core-interfaces#TelemetryBaseEventPropertyType},
+ * as well as callbacks that return that type.
+ *
+ * @example Sample usage
+ * ```typescript
+ * {
+ * 	// ...Other properties being added to a telemetry event
+ * 	...tagData("someTag", {foo: 1, bar: 2}),
+ * 	// ...
+ * }
+ * ```
+ * This will result in `foo` and `bar` added to the event with their values tagged.
+ *
+ * @internal
+ */
+export const tagData = (tag, values) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+Object.entries(values)
+    .filter((e) => e[1] !== undefined)
+    // eslint-disable-next-line unicorn/no-array-reduce, unicorn/prefer-object-from-entries
+    .reduce((pv, cv) => {
+    const [key, value] = cv;
+    // The ternary form is less legible in this case.
+    // eslint-disable-next-line unicorn/prefer-ternary
+    if (typeof value === "function") {
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+        pv[key] = () => {
+            return { tag, value: value() };
+        };
     }
-    reportError(message, event, err) {
-        const error = new Error(message);
-        error.error = error;
-        error.event = event;
-        // report to console as exception can be eaten
-        console.error(message);
-        console.error(error);
-        throw error;
+    else {
+        pv[key] = { tag, value };
     }
-}
+    return pv;
+}, {});
+/**
+ * Tags all provided `values` as {@link TelemetryDataTag.CodeArtifact}.
+ *
+ * @param values - The values to be tagged.
+ *
+ * @remarks
+ * It supports properties of type {@link @fluidframework/core-interfaces#TelemetryBaseEventPropertyType},
+ * as well as callbacks that return that type.
+ *
+ * @example Sample usage
+ * ```typescript
+ * {
+ * 	// ...Other properties being added to a telemetry event
+ * 	...tagCodeArtifacts("someTag", {foo: 1, bar: 2}),
+ * 	// ...
+ * }
+ * ```
+ * This will result in `foo` and `bar` added to the event with their values tagged as {@link TelemetryDataTag.CodeArtifact}.
+ *
+ * @see {@link tagData}
+ *
+ * @internal
+ */
+export const tagCodeArtifacts = (values) => tagData(TelemetryDataTag.CodeArtifact, values);
 //# sourceMappingURL=logger.js.map