@visulima/pail 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/processor/redact-processor.js

@@ -9,7 +9,8 @@ class RedactProcessor {
    * @param options Additional redaction options
    */
   constructor(rules, options) {
-    this.#redact = (input) => redact(input, rules || standardRules, options);
+    const effectiveRules = rules ?? standardRules;
+    this.#redact = (input) => redact(input, effectiveRules, options);
   }
   /**
    * Processes log metadata to redact sensitive information.

package/dist/processor/sampling-processor.d.ts

@@ -0,0 +1,111 @@
+import type { Meta, Processor } from "../types.d.ts";
+/**
+ * Head sampling configuration.
+ *
+ * Controls random sampling rates per log level. Each key is a log level name
+ * and the value is the percentage (0-100) of logs at that level to keep.
+ * Levels not listed default to 100 (keep all).
+ * @example
+ * ```typescript
+ * const headSampling: HeadSamplingConfig = {
+ *   debug: 0,      // Drop all debug logs
+ *   informational: 10,  // Keep 10% of info logs
+ *   warning: 50,   // Keep 50% of warning logs
+ *   error: 100,    // Keep all error logs
+ * };
+ * ```
+ */
+type HeadSamplingConfig = Partial<Record<string, number>>;
+/**
+ * Tail sampling condition function.
+ *
+ * A function that receives the log metadata and returns true if the log
+ * should be force-kept regardless of head sampling. This allows keeping
+ * important logs based on their content (e.g., errors, slow operations).
+ * @template L - The log level type
+ */
+type TailSamplingCondition<L extends string = string> = (meta: Readonly<Meta<L>>) => boolean;
+/**
+ * Sampling processor configuration options.
+ */
+interface SamplingProcessorOptions<L extends string = string> {
+    /**
+     * Head sampling rates per log level.
+     *
+     * A map of log level to sampling percentage (0-100).
+     * Levels not specified default to 100 (keep all).
+     * Set to 0 to drop all logs at that level.
+     */
+    head?: HeadSamplingConfig;
+    /**
+     * Tail sampling conditions.
+     *
+     * An array of condition functions that can force-keep a log entry
+     * even if it was dropped by head sampling. If any condition returns true,
+     * the log is kept.
+     */
+    tail?: TailSamplingCondition<L>[];
+}
+/**
+ * Sampling Processor.
+ *
+ * Inspired by evlog's production sampling strategy, this processor implements
+ * both head sampling (random per-level) and tail sampling (force-keep based
+ * on conditions) to control log volume in production environments.
+ *
+ * **Head sampling** randomly drops a percentage of logs per level. This is
+ * evaluated first and provides broad volume control.
+ *
+ * **Tail sampling** can override head sampling to force-keep important logs
+ * based on their content. For example, you might drop 90% of info logs but
+ * force-keep any that contain error information or relate to slow operations.
+ *
+ * When a log is dropped by sampling, the processor sets a `__dropped: true`
+ * boolean flag on the meta object. Reporters should check for this flag and
+ * skip entries where `__dropped` is `true`.
+ * @template L - The log level type
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ * import SamplingProcessor from "@visulima/pail/processor/sampling";
+ *
+ * const logger = createPail({
+ *   processors: [
+ *     new SamplingProcessor({
+ *       head: {
+ *         debug: 0,         // Drop all debug logs
+ *         informational: 10, // Keep 10% of info logs
+ *         warning: 50,      // Keep 50% of warnings
+ *         error: 100,       // Keep all errors
+ *       },
+ *       tail: [
+ *         // Force-keep logs with errors regardless of head sampling
+ *         (meta) => meta.error !== undefined,
+ *         // Force-keep logs from critical scopes
+ *         (meta) => meta.scope?.includes("payment") ?? false,
+ *       ],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare class SamplingProcessor<L extends string = string> implements Processor<L> {
+    #private;
+    /**
+     * Creates a new SamplingProcessor instance.
+     * @param options Sampling configuration options
+     */
+    constructor(options?: SamplingProcessorOptions<L>);
+    /**
+     * Processes log metadata to apply sampling rules.
+     *
+     * First evaluates head sampling (random per-level), then checks tail
+     * sampling conditions. If a log is dropped, the meta is marked with
+     * `__dropped: true` so reporters can skip it.
+     * @param meta The log metadata to process
+     * @returns The processed metadata, potentially marked as dropped
+     */
+    process(meta: Meta<L>): Meta<L>;
+}
+export default SamplingProcessor;
+export type { HeadSamplingConfig, SamplingProcessorOptions, TailSamplingCondition };

package/dist/processor/sampling-processor.js

@@ -0,0 +1,59 @@
+class SamplingProcessor {
+  #headRates;
+  #tailConditions;
+  /**
+   * Creates a new SamplingProcessor instance.
+   * @param options Sampling configuration options
+   */
+  constructor(options = {}) {
+    this.#headRates = options.head ?? {};
+    this.#tailConditions = options.tail ?? [];
+  }
+  /**
+   * Processes log metadata to apply sampling rules.
+   *
+   * First evaluates head sampling (random per-level), then checks tail
+   * sampling conditions. If a log is dropped, the meta is marked with
+   * `__dropped: true` so reporters can skip it.
+   * @param meta The log metadata to process
+   * @returns The processed metadata, potentially marked as dropped
+   */
+  process(meta) {
+    const level = meta.type.level;
+    if (this.#shouldDrop(level) && !this.#shouldForceKeep(meta)) {
+      return { ...meta, dropped: true };
+    }
+    return meta;
+  }
+  /**
+   * Evaluates head sampling for the given log level.
+   * @returns true if the log should be dropped
+   */
+  #shouldDrop(level) {
+    const rate = this.#headRates[level];
+    if (rate === void 0) {
+      return false;
+    }
+    if (rate <= 0) {
+      return true;
+    }
+    if (rate >= 100) {
+      return false;
+    }
+    return Math.random() * 100 >= rate;
+  }
+  /**
+   * Evaluates tail sampling conditions.
+   * @returns true if any condition forces keeping the log
+   */
+  #shouldForceKeep(meta) {
+    for (let i = 0; i < this.#tailConditions.length; i += 1) {
+      if (this.#tailConditions[i](meta)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+export { SamplingProcessor as default };

package/dist/reporter/file/json-file-reporter.js

@@ -1,4 +1,4 @@
-import { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-BaZ33PlE.js';
+import { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-nOj0Ft1F.js';
 
 class SafeStreamHandler {
   #ready = true;

package/dist/reporter/http/abstract-http-reporter.js

@@ -20,7 +20,7 @@ const __cjs_getBuiltinModule = (module) => {
 const {
   Buffer
 } = __cjs_getBuiltinModule("node:buffer");
-import { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-BaZ33PlE.js';
+import { AbstractJsonReporter } from '../../packem_shared/AbstractJsonReporter-nOj0Ft1F.js';
 const {
   gzipSync
 } = __cjs_getBuiltinModule("node:zlib");
@@ -33,24 +33,25 @@ const compressData = async (data) => {
     const reader = stream.readable.getReader();
     const encoder = new TextEncoder();
     const chunks = [];
-    writer.write(encoder.encode(data));
-    writer.close();
+    await writer.write(encoder.encode(data));
+    await writer.close();
     let done = false;
     while (!done) {
-      const result2 = await reader.read();
-      done = result2.done ?? false;
-      if (result2.value) {
-        chunks.push(result2.value);
+      const result = await reader.read();
+      done = result.done;
+      if (result.value) {
+        chunks.push(result.value);
       }
     }
     const totalLength = chunks.reduce((accumulator, chunk) => accumulator + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
+    const resultBuffer = new Uint8Array(totalLength);
     let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
+    for (let i = 0; i < chunks.length; i += 1) {
+      const chunk = chunks[i];
+      resultBuffer.set(chunk, offset);
       offset += chunk.length;
     }
-    return result;
+    return resultBuffer;
   }
   return gzipSync(data);
 };
@@ -125,7 +126,7 @@ const processResponse = async (response, url, method, headers, body, onDebugRequ
     return false;
   }
   if (response.status < 500 && response.status !== 429) {
-    const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+    const error = new Error(`HTTP ${String(response.status)}: ${response.statusText}`);
     if (onError) {
       onError(error);
     }
@@ -185,7 +186,7 @@ const sendWithRetry = async (url, method, headers, body, maxRetries, retryDelay,
         continue;
       }
       if (!response.ok) {
-        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+        const error = new Error(`HTTP ${String(response.status)}: ${response.statusText}`);
         if (onError) {
           onError(error);
         }
@@ -298,7 +299,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
       const logEntrySize = this.edgeCompat || typeof TextEncoder === "undefined" ? Buffer.byteLength(payload, "utf8") : new TextEncoder().encode(payload).length;
       if (logEntrySize > this.maxLogSize) {
         const error = new LogSizeError(
-          `Log entry exceeds maximum size of ${this.maxLogSize} bytes. Size: ${logEntrySize} bytes`,
+          `Log entry exceeds maximum size of ${String(this.maxLogSize)} bytes. Size: ${String(logEntrySize)} bytes`,
           { data: payloadTemplate.data, logLevel: logLevelString, message: messageString },
           logEntrySize,
           this.maxLogSize
@@ -330,17 +331,15 @@ class AbstractHttpReporter extends AbstractJsonReporter {
     const payloadSizeWithEntry = this.currentBatchSize + logEntrySize + this.batchSendDelimiter.length;
     const payloadSizeThreshold = this.maxPayloadSize * 0.9;
     if (payloadSizeWithEntry > payloadSizeThreshold && this.batchQueue.length > 0) {
-      this.processBatch();
+      void this.processBatch();
     }
     this.batchQueue.push(payload);
     this.currentBatchSize += logEntrySize + this.batchSendDelimiter.length;
-    if (!this.batchTimeout) {
-      this.batchTimeout = setTimeout(() => {
-        this.processBatch();
-      }, this.batchSendTimeout);
-    }
+    this.batchTimeout ??= setTimeout(() => {
+      void this.processBatch();
+    }, this.batchSendTimeout);
     if (this.batchQueue.length >= this.batchSize) {
-      this.processBatch();
+      void this.processBatch();
     }
   }
   /**
@@ -371,7 +370,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
     } finally {
       this.isProcessingBatch = false;
       if (this.batchQueue.length > 0) {
-        this.processBatch();
+        void this.processBatch();
       }
     }
   }
@@ -404,9 +403,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
    */
   async sendPayload(payload, contentType) {
     const headers = typeof this.headers === "function" ? this.headers() : { ...this.headers };
-    if (!headers["content-type"]) {
-      headers["content-type"] = contentType ?? this.contentType;
-    }
+    headers["content-type"] ??= contentType ?? this.contentType;
     let finalPayload = payload;
     if (this.compression && !this.edgeCompat) {
       try {
@@ -414,7 +411,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
         headers["content-encoding"] = "gzip";
       } catch (error) {
         if (this.onError) {
-          this.onError(new Error(`Compression failed: ${error}`));
+          this.onError(new Error(`Compression failed: ${String(error)}`));
         }
       }
     }

package/dist/reporter/http/http-reporter.edge-light.js

@@ -36,7 +36,7 @@ const ErrorProto = Object.create(
   {},
   {
     cause: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
@@ -46,62 +46,89 @@ const ErrorProto = Object.create(
       writable: true
     },
     errors: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
     message: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
     name: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     },
     stack: {
-      enumerable: true,
+      enumerable: false,
       value: void 0,
       writable: true
     }
   }
 );
 const toJsonWasCalled = /* @__PURE__ */ new WeakSet();
+const makePropertiesEnumerable = (object) => {
+  const props = Object.getOwnPropertyNames(object);
+  for (const prop of props) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, prop);
+    if (descriptor) {
+      if (!descriptor.enumerable) {
+        Object.defineProperty(object, prop, {
+          ...descriptor,
+          enumerable: true
+        });
+      }
+      if (descriptor.value && typeof descriptor.value === "object" && !Array.isArray(descriptor.value) && (Object.getPrototypeOf(descriptor.value) === Object.prototype || Object.getPrototypeOf(descriptor.value) === null)) {
+        makePropertiesEnumerable(descriptor.value);
+      }
+    }
+  }
+};
 const toJSON = (from) => {
   toJsonWasCalled.add(from);
   const json = from.toJSON();
   toJsonWasCalled.delete(from);
+  if (
+    // Only make properties enumerable if the object is extensible
+    // Non-extensible objects (like when toJSON returns 'this') should preserve original enumerability
+    Object.isExtensible(json)
+  ) {
+    makePropertiesEnumerable(json);
+  }
   return json;
 };
 const serializeValue = (value, seen, depth, options) => {
   if (value && value instanceof Uint8Array && value.constructor.name === "Buffer") {
     return "[object Buffer]";
   }
-  if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
+  if (value !== null && typeof value === "object" && "pipe" in value && typeof value.pipe === "function") {
     return "[object Stream]";
   }
   if (value instanceof Error) {
-    if (seen.includes(value)) {
+    if (seen.has(value)) {
       return "[Circular]";
     }
     depth += 1;
     return _serialize(value, options, seen, depth);
   }
-  if (options.useToJSON && typeof value.toJSON === "function") {
+  if (options.useToJSON && value !== null && typeof value === "object" && "toJSON" in value && typeof value.toJSON === "function") {
     return value.toJSON();
   }
-  if (typeof value === "object" && value instanceof Date) {
+  if (value instanceof Date) {
     return value.toISOString();
   }
   if (typeof value === "function") {
     return `[Function: ${value.name || "anonymous"}]`;
   }
+  if (typeof value === "bigint") {
+    return `${String(value)}n`;
+  }
   if (isPlainObject(value)) {
-    depth += 1;
-    if (options.maxDepth && depth >= options.maxDepth) {
+    if (options.maxDepth !== void 0 && options.maxDepth !== Number.POSITIVE_INFINITY && depth + 1 >= options.maxDepth) {
       return {};
     }
+    depth += 1;
     const plainObject = {};
     for (const key in value) {
       plainObject[key] = serializeValue(value[key], seen, depth, options);
@@ -115,7 +142,7 @@ const serializeValue = (value, seen, depth, options) => {
   }
 };
 const _serialize = (error, options, seen, depth) => {
-  seen.push(error);
+  seen.add(error);
   if (options.maxDepth === 0) {
     return {};
   }
@@ -123,31 +150,88 @@ const _serialize = (error, options, seen, depth) => {
     return toJSON(error);
   }
   const protoError = Object.create(ErrorProto);
-  protoError.name = Object.prototype.toString.call(error.constructor) === "[object Function]" ? error.constructor.name : error.name;
-  protoError.message = error.message;
-  protoError.stack = error.stack;
+  Object.defineProperty(protoError, "name", {
+    configurable: true,
+    enumerable: true,
+    value: Object.prototype.toString.call(error.constructor) === "[object Function]" ? error.constructor.name : error.name,
+    writable: true
+  });
+  Object.defineProperty(protoError, "message", {
+    configurable: true,
+    enumerable: true,
+    value: error.message,
+    writable: true
+  });
+  Object.defineProperty(protoError, "stack", {
+    configurable: true,
+    enumerable: true,
+    value: error.stack,
+    writable: true
+  });
   if (Array.isArray(error.errors)) {
     const aggregateErrors = [];
     for (const aggregateError of error.errors) {
       if (!(aggregateError instanceof Error)) {
         throw new TypeError("All errors in the 'errors' property must be instances of Error");
       }
-      if (seen.includes(aggregateError)) {
-        protoError.errors = [];
+      if (seen.has(aggregateError)) {
+        Object.defineProperty(protoError, "errors", {
+          configurable: true,
+          enumerable: true,
+          value: [],
+          writable: true
+        });
         return protoError;
       }
       aggregateErrors.push(_serialize(aggregateError, options, seen, depth));
     }
-    protoError.errors = aggregateErrors;
+    Object.defineProperty(protoError, "errors", {
+      configurable: true,
+      enumerable: true,
+      value: aggregateErrors,
+      writable: true
+    });
   }
-  if (error.cause instanceof Error && !seen.includes(error.cause)) {
-    protoError.cause = _serialize(error.cause, options, seen, depth);
+  const causeValue = error.cause;
+  if (causeValue !== void 0 && causeValue !== null) {
+    if (causeValue instanceof Error) {
+      if (seen.has(causeValue)) {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: "[Circular]",
+          writable: true
+        });
+      } else {
+        Object.defineProperty(protoError, "cause", {
+          configurable: true,
+          enumerable: true,
+          value: _serialize(causeValue, options, seen, depth),
+          writable: true
+        });
+      }
+    } else {
+      const serializedCause = serializeValue(causeValue, seen, depth, options);
+      Object.defineProperty(protoError, "cause", {
+        configurable: true,
+        enumerable: true,
+        value: serializedCause,
+        writable: true
+      });
+    }
   }
   for (const key in error) {
-    if (protoError[key] === void 0) {
-      const value = error[key];
-      protoError[key] = serializeValue(value, seen, depth, options);
+    if (key === "name" || key === "message" || key === "stack" || key === "cause" || key === "errors") {
+      continue;
     }
+    const value = error[key];
+    const serializedValue = serializeValue(value, seen, depth, options);
+    Object.defineProperty(protoError, key, {
+      configurable: true,
+      enumerable: true,
+      value: serializedValue,
+      writable: true
+    });
   }
   if (Array.isArray(options.exclude) && options.exclude.length > 0) {
     for (const key of options.exclude) {
@@ -166,7 +250,7 @@ const serialize = (error, options = {}) => _serialize(
     maxDepth: options.maxDepth ?? Number.POSITIVE_INFINITY,
     useToJSON: options.useToJSON ?? false
   },
-  [],
+  /* @__PURE__ */ new Set(),
   0
 );
 
@@ -188,7 +272,6 @@ class AbstractJsonReporter {
    * Sets a custom stringify function for object serialization.
    * @param function_ The stringify function to use for serialization
    */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
   setStringify(function_) {
     this.stringify = function_;
   }
@@ -199,19 +282,16 @@ class AbstractJsonReporter {
       rest.label = rest.label.trim();
     }
     if (file) {
-      rest.file = `${file.name}:${file.line}${file.column ? `:${file.column}` : ""}`;
-    }
-    if (message === EMPTY_SYMBOL) {
-      rest.message = void 0;
-    } else {
-      rest.message = message;
+      rest.file = `${file.name ?? ""}:${String(file.line)}${file.column ? `:${String(file.column)}` : ""}`;
     }
+    rest.message = message === EMPTY_SYMBOL ? void 0 : message;
     if (error) {
       rest.error = serialize(error, this.errorOptions);
     }
     if (context) {
       const newContext = [];
-      for (const item of context) {
+      for (let i = 0; i < context.length; i += 1) {
+        const item = context[i];
         if (item === EMPTY_SYMBOL) {
           continue;
         }
@@ -235,24 +315,25 @@ const compressData = async (data) => {
     const reader = stream.readable.getReader();
     const encoder = new TextEncoder();
     const chunks = [];
-    writer.write(encoder.encode(data));
-    writer.close();
+    await writer.write(encoder.encode(data));
+    await writer.close();
     let done = false;
     while (!done) {
-      const result2 = await reader.read();
-      done = result2.done ?? false;
-      if (result2.value) {
-        chunks.push(result2.value);
+      const result = await reader.read();
+      done = result.done;
+      if (result.value) {
+        chunks.push(result.value);
       }
     }
     const totalLength = chunks.reduce((accumulator, chunk) => accumulator + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
+    const resultBuffer = new Uint8Array(totalLength);
     let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
+    for (let i = 0; i < chunks.length; i += 1) {
+      const chunk = chunks[i];
+      resultBuffer.set(chunk, offset);
       offset += chunk.length;
     }
-    return result;
+    return resultBuffer;
   }
   return gzipSync(data);
 };
@@ -327,7 +408,7 @@ const processResponse = async (response, url, method, headers, body, onDebugRequ
     return false;
   }
   if (response.status < 500 && response.status !== 429) {
-    const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+    const error = new Error(`HTTP ${String(response.status)}: ${response.statusText}`);
     if (onError) {
       onError(error);
     }
@@ -387,7 +468,7 @@ const sendWithRetry = async (url, method, headers, body, maxRetries, retryDelay,
         continue;
       }
       if (!response.ok) {
-        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+        const error = new Error(`HTTP ${String(response.status)}: ${response.statusText}`);
         if (onError) {
           onError(error);
         }
@@ -500,7 +581,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
       const logEntrySize = this.edgeCompat || typeof TextEncoder === "undefined" ? Buffer.byteLength(payload, "utf8") : new TextEncoder().encode(payload).length;
       if (logEntrySize > this.maxLogSize) {
         const error = new LogSizeError(
-          `Log entry exceeds maximum size of ${this.maxLogSize} bytes. Size: ${logEntrySize} bytes`,
+          `Log entry exceeds maximum size of ${String(this.maxLogSize)} bytes. Size: ${String(logEntrySize)} bytes`,
           { data: payloadTemplate.data, logLevel: logLevelString, message: messageString },
           logEntrySize,
           this.maxLogSize
@@ -532,17 +613,15 @@ class AbstractHttpReporter extends AbstractJsonReporter {
     const payloadSizeWithEntry = this.currentBatchSize + logEntrySize + this.batchSendDelimiter.length;
     const payloadSizeThreshold = this.maxPayloadSize * 0.9;
     if (payloadSizeWithEntry > payloadSizeThreshold && this.batchQueue.length > 0) {
-      this.processBatch();
+      void this.processBatch();
     }
     this.batchQueue.push(payload);
     this.currentBatchSize += logEntrySize + this.batchSendDelimiter.length;
-    if (!this.batchTimeout) {
-      this.batchTimeout = setTimeout(() => {
-        this.processBatch();
-      }, this.batchSendTimeout);
-    }
+    this.batchTimeout ??= setTimeout(() => {
+      void this.processBatch();
+    }, this.batchSendTimeout);
     if (this.batchQueue.length >= this.batchSize) {
-      this.processBatch();
+      void this.processBatch();
     }
   }
   /**
@@ -573,7 +652,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
     } finally {
       this.isProcessingBatch = false;
       if (this.batchQueue.length > 0) {
-        this.processBatch();
+        void this.processBatch();
       }
     }
   }
@@ -606,9 +685,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
    */
   async sendPayload(payload, contentType) {
     const headers = typeof this.headers === "function" ? this.headers() : { ...this.headers };
-    if (!headers["content-type"]) {
-      headers["content-type"] = contentType ?? this.contentType;
-    }
+    headers["content-type"] ??= contentType ?? this.contentType;
     let finalPayload = payload;
     if (this.compression && !this.edgeCompat) {
       try {
@@ -616,7 +693,7 @@ class AbstractHttpReporter extends AbstractJsonReporter {
         headers["content-encoding"] = "gzip";
       } catch (error) {
         if (this.onError) {
-          this.onError(new Error(`Compression failed: ${error}`));
+          this.onError(new Error(`Compression failed: ${String(error)}`));
         }
       }
     }