@fluidframework/telemetry-utils 0.59.4001 → 1.1.0-75972

package/src/errorLogging.ts

@@ -88,10 +88,6 @@ function patchLegacyError(
     }
 }
 
-// errorType "genericError" is used as a default value throughout the code.
-// Note that this matches ContainerErrorType/DriverErrorType's genericError
-const defaultErrorTypeForNormalize = "genericError";
-
 /**
  * Normalize the given error yielding a valid Fluid Error
  * @returns A valid Fluid Error with any provided annotations applied
@@ -115,17 +111,11 @@ export function normalizeError(
 
     // We have to construct a new Fluid Error, copying safe properties over
     const { message, stack } = extractLogSafeErrorProperties(error, false /* sanitizeStack */);
-    const fluidError: IFluidErrorBase = new SimpleFluidError({
-        errorType: defaultErrorTypeForNormalize,
+    const fluidError: IFluidErrorBase = new NormalizedExternalError({
         message,
         stack,
     });
 
-    fluidError.addTelemetryProperties({
-        ...annotations.props,
-        untrustedOrigin: 1, // This will let us filter to errors not originated by our own code
-    });
-
     // We need to preserve these properties which are used in a non-typesafe way throughout driver code (see #8743)
     // Anywhere they are set should be on a valid Fluid Error that would have been returned above,
     // but we can't prove it with the types, so adding this defensive measure.
@@ -138,6 +128,14 @@ export function normalizeError(
         // This is only interesting for non-objects
         fluidError.addTelemetryProperties({ typeofError: typeof (error) });
     }
+
+    const originalErrorTelemetryProps = isILoggingError(error) ? error.getTelemetryProperties() : {};
+    fluidError.addTelemetryProperties({
+        ...originalErrorTelemetryProps,
+        ...annotations.props,
+        untrustedOrigin: 1, // This will let us filter to errors not originated by our own code
+    });
+
     return fluidError;
 }
 
@@ -175,9 +173,8 @@ export function generateStack(): string | undefined {
 }
 
 /**
- * Create a new error, wrapping and caused by the given unknown error.
- * Copies the inner error's message and stack over but otherwise uses newErrorFn to define the error.
- * The inner error's instance id will also be logged for telemetry analysis.
+ * Create a new error using newErrorFn, wrapping and caused by the given unknown error.
+ * Copies the inner error's stack, errorInstanceId and telemetry props over to the new error if present
  * @param innerError - An error from untrusted/unknown origins
  * @param newErrorFn - callback that will create a new error given the original error's message
  * @returns A new error object "wrapping" the given error
@@ -198,7 +195,7 @@ export function wrapError<T extends LoggingError>(
     }
 
     // Mark external errors with untrustedOrigin flag
-    if (originatedAsExternalError(innerError)) {
+    if (isExternalError(innerError)) {
         newError.addTelemetryProperties({ untrustedOrigin: 1 });
     }
 
@@ -210,6 +207,12 @@ export function wrapError<T extends LoggingError>(
         newError.addTelemetryProperties({ innerErrorInstanceId: innerError.errorInstanceId });
     }
 
+    // Lastly, copy over all other telemetry properties. Note these will not overwrite existing properties
+    // This will include the untrustedOrigin property if the inner error itself was created from an external error
+    if (isILoggingError(innerError)) {
+        newError.addTelemetryProperties(innerError.getTelemetryProperties());
+    }
+
     return newError;
 }
 
@@ -245,14 +248,6 @@ function overwriteStack(error: IFluidErrorBase | LoggingError, stack: string) {
     }
 }
 
-/**
- * True for any error object that is either external itself or is a wrapped/normalized external error
- * False for any error we created and raised within the FF codebase.
- */
-export function originatedAsExternalError(e: any): boolean {
-    return !isValidLegacyError(e) || (e.getTelemetryProperties().untrustedOrigin === 1);
-}
-
 /**
  * True for any error object that is an (optionally normalized) external error
  * False for any error we created and raised within the FF codebase, or wrapped in a well-known error type
@@ -260,7 +255,7 @@ export function originatedAsExternalError(e: any): boolean {
 export function isExternalError(e: any): boolean {
     return !isValidLegacyError(e) ||
         (e.getTelemetryProperties().untrustedOrigin === 1 &&
-         e.errorType === defaultErrorTypeForNormalize);
+         e.errorType === NormalizedExternalError.normalizedErrorType);
 }
 
 /**
@@ -316,19 +311,18 @@ export const getCircularReplacer = () => {
             }
             seen.add(value);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return value;
     };
 };
 
 /**
  * Base class for "trusted" errors we create, whose properties can generally be logged to telemetry safely.
- * All properties set on the object, or passed in (via the constructor or getTelemetryProperties),
+ * All properties set on the object, or passed in (via the constructor or addTelemetryProperties),
  * will be logged in accordance with their tag, if present.
  *
  * PLEASE take care to avoid setting sensitive data on this object without proper tagging!
  */
-export class LoggingError extends Error implements ILoggingError, Pick<IFluidErrorBase, "errorInstanceId"> {
+export class LoggingError extends Error implements ILoggingError, Omit<IFluidErrorBase, "errorType"> {
     private _errorInstanceId = uuid();
     get errorInstanceId() { return this._errorInstanceId; }
     overwriteErrorInstanceId(id: string) { this._errorInstanceId = id; }
@@ -381,19 +375,22 @@ export class LoggingError extends Error implements ILoggingError, Pick<IFluidErr
     }
 }
 
-/** Simple implementation of IFluidErrorBase, extending LoggingError */
-class SimpleFluidError extends LoggingError implements IFluidErrorBase {
-    readonly errorType: string;
+/** The Error class used when normalizing an external error */
+class NormalizedExternalError extends LoggingError {
+    // errorType "genericError" is used as a default value throughout the code.
+    // Note that this matches ContainerErrorType/DriverErrorType's genericError
+    static readonly normalizedErrorType = "genericError";
+
+    errorType = NormalizedExternalError.normalizedErrorType;
 
     constructor(
         errorProps: Pick<IFluidErrorBase,
             | "message"
             | "stack"
-            | "errorType"
         >,
     ) {
         super(errorProps.message);
-        this.errorType = errorProps.errorType;
+
         if (errorProps.stack !== undefined) {
             overwriteStack(this, errorProps.stack);
         }

package/src/logger.ts

@@ -31,9 +31,14 @@ import {
  * 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 enum TelemetryDataTag {
-    /** Data containing terms from code packages that may have been dynamically loaded */
+export enum 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.
+     */
     PackageData = "PackageData",
+    /** 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",
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/telemetry-utils";
-export const pkgVersion = "0.59.4001";
+export const pkgVersion = "1.1.0-75972";