effect 4.0.0-beta.4 → 4.0.0-beta.41

package/dist/ErrorReporter.d.ts

@@ -0,0 +1,374 @@
+/**
+ * Pluggable error reporting for Effect programs.
+ *
+ * Reporting is triggered by `Effect.withErrorReporting`,
+ * `ErrorReporter.report`, or built-in reporting boundaries in the HTTP and
+ * RPC server modules.
+ *
+ * Each reporter receives a structured callback with the failing `Cause`, a
+ * pretty-printed `Error`, severity, and any extra attributes attached to the
+ * original error — making it straightforward to forward failures to Sentry,
+ * Datadog, or a custom logging backend.
+ *
+ * Use the annotation symbols (`ignore`, `severity`, `attributes`) on your
+ * error classes to control reporting behavior per-error.
+ *
+ * @example
+ * ```ts
+ * import { Data, Effect, ErrorReporter } from "effect"
+ *
+ * // A reporter that logs to the console
+ * const consoleReporter = ErrorReporter.make(({ error, severity }) => {
+ *   console.error(`[${severity}]`, error.message)
+ * })
+ *
+ * // An error that should be ignored by reporters
+ * class NotFoundError extends Data.TaggedError("NotFoundError")<{}> {
+ *   readonly [ErrorReporter.ignore] = true
+ * }
+ *
+ * // An error with custom severity and attributes
+ * class RateLimitError extends Data.TaggedError("RateLimitError")<{
+ *   readonly retryAfter: number
+ * }> {
+ *   readonly [ErrorReporter.severity] = "Warn" as const
+ *   readonly [ErrorReporter.attributes] = {
+ *     retryAfter: this.retryAfter
+ *   }
+ * }
+ *
+ * // Opt in to error reporting with Effect.withErrorReporting
+ * const program = Effect.gen(function*() {
+ *   return yield* new RateLimitError({ retryAfter: 60 })
+ * }).pipe(
+ *   Effect.withErrorReporting,
+ *   Effect.provide(ErrorReporter.layer([consoleReporter]))
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ */
+import type * as Cause from "./Cause.ts";
+import * as Effect from "./Effect.ts";
+import type * as Fiber from "./Fiber.ts";
+import * as Layer from "./Layer.ts";
+import type { Severity } from "./LogLevel.ts";
+import type { ReadonlyRecord } from "./Record.ts";
+import type * as Scope from "./Scope.ts";
+import type * as ServiceMap from "./ServiceMap.ts";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export type TypeId = "~effect/ErrorReporter";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export declare const TypeId: TypeId;
+/**
+ * An `ErrorReporter` receives reported failures and forwards them to an
+ * external system (logging service, error tracker, etc.).
+ *
+ * Reporting is triggered by `Effect.withErrorReporting`,
+ * `ErrorReporter.report`, or built-in boundaries in the HTTP and RPC server
+ * modules. Use {@link make} to create a reporter — it handles deduplication
+ * and per-error annotation extraction automatically.
+ *
+ * @since 4.0.0
+ * @category Models
+ */
+export interface ErrorReporter {
+    readonly [TypeId]: TypeId;
+    report(options: {
+        readonly cause: Cause.Cause<unknown>;
+        readonly fiber: Fiber.Fiber<unknown, unknown>;
+        readonly timestamp: bigint;
+    }): void;
+}
+/**
+ * Creates an `ErrorReporter` from a callback.
+ *
+ * The returned reporter automatically deduplicates causes and individual
+ * errors (the same object is never reported twice), skips interruptions,
+ * and resolves the `ignore`, `severity`, and `attributes` annotations on
+ * each error before invoking your callback.
+ *
+ * @example
+ * ```ts
+ * import { ErrorReporter } from "effect"
+ *
+ * // Forward every failure to the console
+ * const consoleReporter = ErrorReporter.make(
+ *   ({ error, severity, attributes }) => {
+ *     console.error(`[${severity}]`, error.message, attributes)
+ *   }
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category Constructors
+ */
+export declare const make: (report: (options: {
+    readonly cause: Cause.Cause<unknown>;
+    readonly error: Error;
+    readonly attributes: ReadonlyRecord<string, unknown>;
+    readonly severity: Severity;
+    readonly fiber: Fiber.Fiber<unknown, unknown>;
+    readonly timestamp: bigint;
+}) => void) => ErrorReporter;
+/**
+ * A `ServiceMap.Reference` holding the set of active `ErrorReporter`s for the
+ * current fiber. Defaults to an empty set (no reporting).
+ *
+ * Prefer {@link layer} to configure reporters via the `Layer` API. Use this
+ * reference directly only when you need low-level control (e.g. reading the
+ * current reporters or swapping them inside a `FiberRef`).
+ *
+ * @since 4.0.0
+ * @category References
+ */
+export declare const CurrentErrorReporters: ServiceMap.Reference<ReadonlySet<ErrorReporter>>;
+/**
+ * Creates a `Layer` that registers one or more `ErrorReporter`s.
+ *
+ * Reporters can be plain `ErrorReporter` values or effectful
+ * `Effect<ErrorReporter>` values that are resolved when the layer is built.
+ *
+ * By default the provided reporters **replace** any previously registered
+ * reporters. Set `mergeWithExisting: true` to add them alongside existing
+ * ones.
+ *
+ * @example
+ * ```ts
+ * import { Effect, ErrorReporter } from "effect"
+ *
+ * const consoleReporter = ErrorReporter.make(({ error, severity }) => {
+ *   console.error(`[${severity}]`, error.message)
+ * })
+ *
+ * const metricsReporter = ErrorReporter.make(({ severity }) => {
+ *   // increment an error counter by severity
+ * })
+ *
+ * // Replace all existing reporters
+ * const ReporterLive = ErrorReporter.layer([
+ *   consoleReporter,
+ *   metricsReporter
+ * ])
+ *
+ * // Add to existing reporters instead of replacing
+ * const ReporterMerged = ErrorReporter.layer(
+ *   [metricsReporter],
+ *   { mergeWithExisting: true }
+ * )
+ *
+ * const program = Effect.fail("boom").pipe(
+ *   Effect.withErrorReporting,
+ *   Effect.provide(ReporterLive)
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category Layers
+ */
+export declare const layer: <const Reporters extends ReadonlyArray<ErrorReporter | Effect.Effect<ErrorReporter, any, any>>>(reporters: Reporters, options?: {
+    readonly mergeWithExisting?: boolean | undefined;
+} | undefined) => Layer.Layer<never, Reporters extends readonly [] ? never : Effect.Error<Reporters[number]>, Exclude<Reporters extends readonly [] ? never : Effect.Services<Reporters[number]>, Scope.Scope>>;
+/**
+ * Manually report a `Cause` to all registered `ErrorReporter`s on the
+ * current fiber.
+ *
+ * This is useful when you want to report an error for observability without
+ * actually failing the fiber.
+ *
+ * @example
+ * ```ts
+ * import { Cause, Effect, ErrorReporter } from "effect"
+ *
+ * // Log the cause for monitoring, then continue with a fallback
+ * const program = Effect.gen(function*() {
+ *   const cause = Cause.fail("something went wrong")
+ *   yield* ErrorReporter.report(cause)
+ *   return "fallback value"
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Reporting
+ */
+export declare const report: <E>(cause: Cause.Cause<E>) => Effect.Effect<void>;
+/**
+ * Interface that errors can implement to control reporting behavior.
+ *
+ * All three annotation properties are optional:
+ * - `[ErrorReporter.ignore]` — when `true`, the error is never reported
+ * - `[ErrorReporter.severity]` — overrides the default `"Error"` severity
+ * - `[ErrorReporter.attributes]` — extra key/value pairs forwarded to reporters
+ *
+ * The global `Error` interface is augmented with `Reportable`, so these
+ * properties are available on all `Error` instances.
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export interface Reportable {
+    readonly [ignore]?: boolean;
+    readonly [severity]?: Severity;
+    readonly [attributes]?: ReadonlyRecord<string, unknown>;
+}
+declare global {
+    interface Error extends Reportable {
+    }
+}
+/**
+ * Symbol key used to mark an error as unreportable.
+ *
+ * Set this property to `true` on any error class to prevent it from being
+ * forwarded to reporters. Useful for expected errors such as HTTP 404s.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class NotFoundError extends Data.TaggedError("NotFoundError")<{}> {
+ *   readonly [ErrorReporter.ignore] = true
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export type ignore = "~effect/ErrorReporter/ignore";
+/**
+ * Symbol key used to mark an error as unreportable.
+ *
+ * Set this property to `true` on any error class to prevent it from being
+ * forwarded to reporters. Useful for expected errors such as HTTP 404s.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class NotFoundError extends Data.TaggedError("NotFoundError")<{}> {
+ *   readonly [ErrorReporter.ignore] = true
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export declare const ignore: ignore;
+/**
+ * Returns `true` if the given value has the `ErrorReporter.ignore` annotation
+ * set to `true`.
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export declare const isIgnored: (u: unknown) => boolean;
+/**
+ * Symbol key used to override the severity level of an error.
+ *
+ * When set, the reporter callback receives this value as `severity` instead
+ * of the default `"Error"`. Accepted values are the `LogLevel.Severity`
+ * literals: `"Trace"`, `"Debug"`, `"Info"`, `"Warn"`, `"Error"`, `"Fatal"`.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class DeprecationWarning extends Data.TaggedError("DeprecationWarning")<{}> {
+ *   readonly [ErrorReporter.severity] = "Warn" as const
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export type severity = "~effect/ErrorReporter/severity";
+/**
+ * Symbol key used to override the severity level of an error.
+ *
+ * When set, the reporter callback receives this value as `severity` instead
+ * of the default `"Error"`. Accepted values are the `LogLevel.Severity`
+ * literals: `"Trace"`, `"Debug"`, `"Info"`, `"Warn"`, `"Error"`, `"Fatal"`.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class DeprecationWarning extends Data.TaggedError("DeprecationWarning")<{}> {
+ *   readonly [ErrorReporter.severity] = "Warn" as const
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export declare const severity: severity;
+/**
+ * Reads the `ErrorReporter.severity` annotation from an error object,
+ * falling back to `"Error"` when unset or invalid.
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export declare const getSeverity: (error: object) => Severity;
+/**
+ * Symbol key used to attach extra key/value metadata to an error report.
+ *
+ * Reporters receive these attributes alongside the error, making it easy to
+ * include contextual information such as user IDs, request IDs, or any
+ * domain-specific data useful for debugging.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class PaymentError extends Data.TaggedError("PaymentError")<{
+ *   readonly orderId: string
+ * }> {
+ *   readonly [ErrorReporter.attributes] = {
+ *     orderId: this.orderId
+ *   }
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export type attributes = "~effect/ErrorReporter/attributes";
+/**
+ * Symbol key used to attach extra key/value metadata to an error report.
+ *
+ * Reporters receive these attributes alongside the error, making it easy to
+ * include contextual information such as user IDs, request IDs, or any
+ * domain-specific data useful for debugging.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class PaymentError extends Data.TaggedError("PaymentError")<{
+ *   readonly orderId: string
+ * }> {
+ *   readonly [ErrorReporter.attributes] = {
+ *     orderId: this.orderId
+ *   }
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export declare const attributes: attributes;
+/**
+ * Reads the `ErrorReporter.attributes` annotation from an error object,
+ * returning an empty record when unset.
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export declare const getAttributes: (error: object) => ReadonlyRecord<string, unknown>;
+//# sourceMappingURL=ErrorReporter.d.ts.map

package/dist/ErrorReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorReporter.d.ts","sourceRoot":"","sources":["../src/ErrorReporter.ts"],"names":[],"mappings":"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"}

package/dist/ErrorReporter.js

@@ -0,0 +1,245 @@
+import * as Effect from "./Effect.js";
+import * as effect from "./internal/effect.js";
+import * as references from "./internal/references.js";
+import * as Layer from "./Layer.js";
+import * as LogLevel from "./LogLevel.js";
+/**
+ * @since 4.0.0
+ * @category Type Identifiers
+ */
+export const TypeId = "~effect/ErrorReporter";
+/**
+ * Creates an `ErrorReporter` from a callback.
+ *
+ * The returned reporter automatically deduplicates causes and individual
+ * errors (the same object is never reported twice), skips interruptions,
+ * and resolves the `ignore`, `severity`, and `attributes` annotations on
+ * each error before invoking your callback.
+ *
+ * @example
+ * ```ts
+ * import { ErrorReporter } from "effect"
+ *
+ * // Forward every failure to the console
+ * const consoleReporter = ErrorReporter.make(
+ *   ({ error, severity, attributes }) => {
+ *     console.error(`[${severity}]`, error.message, attributes)
+ *   }
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category Constructors
+ */
+export const make = report => {
+  const reported = new WeakSet();
+  return {
+    [TypeId]: TypeId,
+    report(options) {
+      if (reported.has(options.cause)) return;
+      reported.add(options.cause);
+      for (let i = 0; i < options.cause.reasons.length; i++) {
+        const reason = options.cause.reasons[i];
+        if (reason._tag === "Interrupt") continue;
+        const original = reason._tag === "Fail" ? reason.error : reason.defect;
+        const isObject = typeof original === "object" && original !== null;
+        if (isObject) {
+          if (reported.has(original)) continue;
+          reported.add(original);
+        }
+        if (isIgnored(original)) continue;
+        const pretty = effect.causePrettyError(original, reason.annotations);
+        report({
+          ...options,
+          error: pretty,
+          severity: isObject ? getSeverity(original) : "Info",
+          attributes: isObject ? getAttributes(original) : emptyAttributes
+        });
+      }
+    }
+  };
+};
+/**
+ * A `ServiceMap.Reference` holding the set of active `ErrorReporter`s for the
+ * current fiber. Defaults to an empty set (no reporting).
+ *
+ * Prefer {@link layer} to configure reporters via the `Layer` API. Use this
+ * reference directly only when you need low-level control (e.g. reading the
+ * current reporters or swapping them inside a `FiberRef`).
+ *
+ * @since 4.0.0
+ * @category References
+ */
+export const CurrentErrorReporters = references.CurrentErrorReporters;
+/**
+ * Creates a `Layer` that registers one or more `ErrorReporter`s.
+ *
+ * Reporters can be plain `ErrorReporter` values or effectful
+ * `Effect<ErrorReporter>` values that are resolved when the layer is built.
+ *
+ * By default the provided reporters **replace** any previously registered
+ * reporters. Set `mergeWithExisting: true` to add them alongside existing
+ * ones.
+ *
+ * @example
+ * ```ts
+ * import { Effect, ErrorReporter } from "effect"
+ *
+ * const consoleReporter = ErrorReporter.make(({ error, severity }) => {
+ *   console.error(`[${severity}]`, error.message)
+ * })
+ *
+ * const metricsReporter = ErrorReporter.make(({ severity }) => {
+ *   // increment an error counter by severity
+ * })
+ *
+ * // Replace all existing reporters
+ * const ReporterLive = ErrorReporter.layer([
+ *   consoleReporter,
+ *   metricsReporter
+ * ])
+ *
+ * // Add to existing reporters instead of replacing
+ * const ReporterMerged = ErrorReporter.layer(
+ *   [metricsReporter],
+ *   { mergeWithExisting: true }
+ * )
+ *
+ * const program = Effect.fail("boom").pipe(
+ *   Effect.withErrorReporting,
+ *   Effect.provide(ReporterLive)
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category Layers
+ */
+export const layer = (reporters, options) => Layer.effect(CurrentErrorReporters, Effect.withFiber(Effect.fnUntraced(function* (fiber) {
+  const currentReporters = new Set(options?.mergeWithExisting === true ? fiber.getRef(references.CurrentErrorReporters) : []);
+  for (const reporter of reporters) {
+    currentReporters.add(Effect.isEffect(reporter) ? yield* reporter : reporter);
+  }
+  return currentReporters;
+})));
+/**
+ * Manually report a `Cause` to all registered `ErrorReporter`s on the
+ * current fiber.
+ *
+ * This is useful when you want to report an error for observability without
+ * actually failing the fiber.
+ *
+ * @example
+ * ```ts
+ * import { Cause, Effect, ErrorReporter } from "effect"
+ *
+ * // Log the cause for monitoring, then continue with a fallback
+ * const program = Effect.gen(function*() {
+ *   const cause = Cause.fail("something went wrong")
+ *   yield* ErrorReporter.report(cause)
+ *   return "fallback value"
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Reporting
+ */
+export const report = cause => Effect.withFiber(fiber => {
+  effect.reportCauseUnsafe(fiber, cause);
+  return Effect.void;
+});
+/**
+ * Symbol key used to mark an error as unreportable.
+ *
+ * Set this property to `true` on any error class to prevent it from being
+ * forwarded to reporters. Useful for expected errors such as HTTP 404s.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class NotFoundError extends Data.TaggedError("NotFoundError")<{}> {
+ *   readonly [ErrorReporter.ignore] = true
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export const ignore = "~effect/ErrorReporter/ignore";
+/**
+ * Returns `true` if the given value has the `ErrorReporter.ignore` annotation
+ * set to `true`.
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export const isIgnored = u => typeof u === "object" && u !== null && ignore in u && u[ignore] === true;
+/**
+ * Symbol key used to override the severity level of an error.
+ *
+ * When set, the reporter callback receives this value as `severity` instead
+ * of the default `"Error"`. Accepted values are the `LogLevel.Severity`
+ * literals: `"Trace"`, `"Debug"`, `"Info"`, `"Warn"`, `"Error"`, `"Fatal"`.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class DeprecationWarning extends Data.TaggedError("DeprecationWarning")<{}> {
+ *   readonly [ErrorReporter.severity] = "Warn" as const
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export const severity = "~effect/ErrorReporter/severity";
+/**
+ * Reads the `ErrorReporter.severity` annotation from an error object,
+ * falling back to `"Error"` when unset or invalid.
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export const getSeverity = error => {
+  if (severity in error && LogLevel.values.includes(error[severity])) {
+    return error[severity];
+  }
+  return "Info";
+};
+/**
+ * Symbol key used to attach extra key/value metadata to an error report.
+ *
+ * Reporters receive these attributes alongside the error, making it easy to
+ * include contextual information such as user IDs, request IDs, or any
+ * domain-specific data useful for debugging.
+ *
+ * @example
+ * ```ts
+ * import { Data, ErrorReporter } from "effect"
+ *
+ * class PaymentError extends Data.TaggedError("PaymentError")<{
+ *   readonly orderId: string
+ * }> {
+ *   readonly [ErrorReporter.attributes] = {
+ *     orderId: this.orderId
+ *   }
+ * }
+ * ```
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export const attributes = "~effect/ErrorReporter/attributes";
+/**
+ * Reads the `ErrorReporter.attributes` annotation from an error object,
+ * returning an empty record when unset.
+ *
+ * @since 4.0.0
+ * @category Annotations
+ */
+export const getAttributes = error => {
+  return attributes in error ? error[attributes] : emptyAttributes;
+};
+const emptyAttributes = {};
+//# sourceMappingURL=ErrorReporter.js.map

package/dist/ErrorReporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorReporter.js","names":["Effect","effect","references","Layer","LogLevel","TypeId","make","report","reported","WeakSet","options","has","cause","add","i","reasons","length","reason","_tag","original","error","defect","isObject","isIgnored","pretty","causePrettyError","annotations","severity","getSeverity","attributes","getAttributes","emptyAttributes","CurrentErrorReporters","layer","reporters","withFiber","fnUntraced","fiber","currentReporters","Set","mergeWithExisting","getRef","reporter","isEffect","reportCauseUnsafe","void","ignore","u","values","includes"],"sources":["../src/ErrorReporter.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}