effect 4.0.1 → 4.0.2

package/src/observability/OtlpMetrics.ts

@@ -39,6 +39,8 @@ import { OtlpSerialization } from "./OtlpSerialization.ts"
  *
  * `"delta"` reports changes since the last export. Each interval is independent with no dependency on previous measurements.
  *
+ * Summaries are always cumulative, regardless of this setting.
+ *
  * **Example** (Configuring aggregation temporality)
  *
  * ```ts import.meta.vitest
@@ -114,7 +116,6 @@ export const make: (options: {
   let previousCounterState = new Map<string, number | bigint>()
   let previousHistogramState = new Map<string, PreviousHistogramState>()
   let previousFrequencyState = new Map<string, Map<string, number>>()
-  let previousSummaryState = new Map<string, PreviousSummaryState>()
   let snapshotSequence = 0
   let committedSnapshotSequence = -1
 
@@ -126,7 +127,6 @@ export const make: (options: {
     const nextCounterState = new Map(previousCounterState)
     const nextHistogramState = new Map(previousHistogramState)
     const nextFrequencyState = new Map(previousFrequencyState)
-    const nextSummaryState = new Map(previousSummaryState)
     const metricData: Array<IMetric> = []
     const metricDataByName = new Map<string, IMetric>()
     const addMetricData = (data: IMetric) => {
@@ -144,7 +144,7 @@ export const make: (options: {
 
     for (let i = 0, len = snapshot.length; i < len; i++) {
       const state = snapshot[i]
-      const unit = state.attributes?.unit ?? state.attributes?.time_unit ?? "1"
+      const unit = toUcumUnit(state.attributes?.unit ?? state.attributes?.time_unit)
       const attributes = state.attributes ? OtlpResource.entriesToAttributes(Object.entries(state.attributes)) : []
       const metricKey = makeMetricKey(state.id, state.attributes)
 
@@ -181,7 +181,7 @@ export const make: (options: {
             timeUnixNano: nowTime
           }
           if (typeof reportValue === "bigint") {
-            dataPoint.asInt = Number(reportValue)
+            dataPoint.asInt = bigintToInt64(reportValue)
           } else {
             dataPoint.asDouble = reportValue
           }
@@ -209,7 +209,7 @@ export const make: (options: {
             timeUnixNano: nowTime
           }
           if (typeof state.state.value === "bigint") {
-            dataPoint.asInt = Number(state.state.value)
+            dataPoint.asInt = bigintToInt64(state.state.value)
           } else {
             dataPoint.asDouble = state.state.value
           }
@@ -344,91 +344,25 @@ export const make: (options: {
           break
         }
         case "Summary": {
-          // Quantiles are always computed fresh from the sliding window
-          // They don't have temporality in the traditional sense
-          const dataPoints: Array<INumberDataPoint> = [{
-            attributes: [...attributes, { key: "quantile", value: { stringValue: "min" } }],
-            startTimeUnixNano: intervalStartTime,
-            timeUnixNano: nowTime,
-            asDouble: state.state.min
-          }]
-          for (const [quantile, value] of state.state.quantiles) {
-            dataPoints.push({
-              attributes: [...attributes, { key: "quantile", value: { stringValue: quantile.toString() } }],
-              startTimeUnixNano: intervalStartTime,
-              timeUnixNano: nowTime,
-              asDouble: value ?? 0
-            })
-          }
-          dataPoints.push({
-            attributes: [...attributes, { key: "quantile", value: { stringValue: "max" } }],
-            startTimeUnixNano: intervalStartTime,
-            timeUnixNano: nowTime,
-            asDouble: state.state.max
-          })
-
-          let reportCount = state.state.count
-          let reportSum = state.state.sum
-
-          if (isDelta) {
-            const previousState = previousSummaryState.get(metricKey)
-            if (previousState !== undefined) {
-              reportCount = state.state.count - previousState.count
-              reportSum = state.state.sum - previousState.sum
-            }
-            nextSummaryState.set(metricKey, {
-              count: state.state.count,
-              sum: state.state.sum
-            })
-          }
-
-          const countDataPoint: INumberDataPoint = {
+          // Count and sum are lifetime totals, so summaries are always cumulative
+          const dataPoint: ISummaryDataPoint = {
             attributes,
-            startTimeUnixNano: intervalStartTime,
-            timeUnixNano: nowTime,
-            asInt: reportCount
-          }
-          const sumDataPoint: INumberDataPoint = {
-            attributes,
-            startTimeUnixNano: intervalStartTime,
+            startTimeUnixNano: startTime,
             timeUnixNano: nowTime,
-            asDouble: reportSum
+            count: state.state.count,
+            sum: state.state.sum,
+            quantileValues: state.state.quantiles.flatMap(([quantile, value]) =>
+              value === undefined ? [] : [{ quantile, value }]
+            )
           }
-
-          if (metricDataByName.has(`${state.id}_quantiles`)) {
-            metricDataByName.get(`${state.id}_quantiles`)!.sum!.dataPoints.push(...dataPoints)
-            metricDataByName.get(`${state.id}_count`)!.sum!.dataPoints.push(countDataPoint)
-            metricDataByName.get(`${state.id}_sum`)!.sum!.dataPoints.push(sumDataPoint)
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id)!.summary!.dataPoints.push(dataPoint)
           } else {
             addMetricData({
-              name: `${state.id}_quantiles`,
+              name: state.id,
               description: state.description!,
               unit,
-              sum: {
-                aggregationTemporality: aggregationTemporalityEnum,
-                isMonotonic: false,
-                dataPoints
-              }
-            })
-            addMetricData({
-              name: `${state.id}_count`,
-              description: state.description!,
-              unit: "1",
-              sum: {
-                aggregationTemporality: aggregationTemporalityEnum,
-                isMonotonic: true,
-                dataPoints: [countDataPoint]
-              }
-            })
-            addMetricData({
-              name: `${state.id}_sum`,
-              description: state.description!,
-              unit: "1",
-              sum: {
-                aggregationTemporality: aggregationTemporalityEnum,
-                isMonotonic: true,
-                dataPoints: [sumDataPoint]
-              }
+              summary: { dataPoints: [dataPoint] }
             })
           }
           break
@@ -451,7 +385,6 @@ export const make: (options: {
         previousCounterState = nextCounterState
         previousHistogramState = nextHistogramState
         previousFrequencyState = nextFrequencyState
-        previousSummaryState = nextSummaryState
         previousExportTimeNanos = nowNanos
         committedSnapshotSequence = currentSnapshotSequence
       })
@@ -567,6 +500,20 @@ const makeMetricKey = (id: string, attributes: Metric.Metric.AttributeSet | unde
   return `${id}:${JSON.stringify(sortedEntries)}`
 }
 
+const ucumUnits = new Map([
+  ["nanoseconds", "ns"],
+  ["microseconds", "us"],
+  ["milliseconds", "ms"],
+  ["seconds", "s"],
+  ["bytes", "By"]
+])
+
+const toUcumUnit = (unit: string | undefined): string => unit === undefined ? "1" : ucumUnits.get(unit) ?? unit
+
+/** OTLP/JSON accepts int64 as a decimal string, which keeps values beyond 2^53 exact */
+const bigintToInt64 = (value: bigint): number | string =>
+  Number.isSafeInteger(Number(value)) ? Number(value) : value.toString()
+
 /** Previous state for histogram delta computation */
 interface PreviousHistogramState {
   readonly count: number
@@ -576,12 +523,6 @@ interface PreviousHistogramState {
   readonly max: number
 }
 
-/** Previous state for summary delta computation */
-interface PreviousSummaryState {
-  readonly count: number
-  readonly sum: number
-}
-
 /** Properties of an InstrumentationScope. */
 interface IInstrumentationScope {
   /** InstrumentationScope name */
@@ -675,7 +616,7 @@ interface INumberDataPoint {
   /** NumberDataPoint asDouble */
   asDouble?: number | null
   /** NumberDataPoint asInt */
-  asInt?: number
+  asInt?: number | string
   /** NumberDataPoint exemplars */
   exemplars?: Array<IExemplar>
   /** NumberDataPoint flags */
@@ -740,9 +681,9 @@ interface ISummaryDataPoint {
   /** SummaryDataPoint attributes */
   attributes?: Array<KeyValue>
   /** SummaryDataPoint startTimeUnixNano */
-  startTimeUnixNano?: number
+  startTimeUnixNano?: Fixed64
   /** SummaryDataPoint timeUnixNano */
-  timeUnixNano?: string
+  timeUnixNano?: Fixed64
   /** SummaryDataPoint count */
   count?: number
   /** SummaryDataPoint sum */

package/src/observability/OtlpResource.ts

@@ -13,6 +13,7 @@ import * as Config from "../Config.ts"
 import * as Effect from "../Effect.ts"
 import { format } from "../Formatter.ts"
 import * as Schema from "../Schema.ts"
+import * as Version from "../Version.ts"
 
 /**
  * OTLP resource metadata attached to exported logs, metrics, and traces.
@@ -28,46 +29,36 @@ export interface Resource {
   droppedAttributesCount: number
 }
 
+const isBrowser = "window" in globalThis || "importScripts" in globalThis
+
 /**
  * Creates an OTLP resource from service metadata and additional attributes.
  *
  * **Details**
  *
- * The resource always includes `service.name`, includes `service.version` when
- * provided, and converts custom attributes into OTLP attribute values.
+ * Adds `telemetry.sdk.*` defaults and converts custom attributes to OTLP values.
+ * Custom attributes override SDK defaults; service options override matching
+ * attributes. Omitted service options add no service attributes.
  *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
  */
 export const make = (options: {
-  readonly serviceName: string
+  readonly serviceName?: string | undefined
   readonly serviceVersion?: string | undefined
   readonly attributes?: Record<string, unknown> | undefined
-}): Resource => {
-  const resourceAttributes = options.attributes
-    ? entriesToAttributes(Object.entries(options.attributes))
-    : []
-  resourceAttributes.push({
-    key: "service.name",
-    value: {
-      stringValue: options.serviceName
-    }
-  })
-  if (options.serviceVersion) {
-    resourceAttributes.push({
-      key: "service.version",
-      value: {
-        stringValue: options.serviceVersion
-      }
-    })
-  }
-
-  return {
-    attributes: resourceAttributes,
-    droppedAttributesCount: 0
-  }
-}
+}): Resource => ({
+  attributes: entriesToAttributes(Object.entries({
+    "telemetry.sdk.name": "effect",
+    "telemetry.sdk.language": isBrowser ? "webjs" : "nodejs",
+    "telemetry.sdk.version": Version.getCurrentVersion(),
+    ...options.attributes,
+    ...(options.serviceName ? { "service.name": options.serviceName } : undefined),
+    ...(options.serviceVersion ? { "service.version": options.serviceVersion } : undefined)
+  })),
+  droppedAttributesCount: 0
+})
 
 /**
  * Creates an OTLP resource from explicit options and OpenTelemetry

package/src/observability/OtlpTracer.ts

@@ -26,6 +26,7 @@ import * as Option from "../Option.ts"
 import type * as Scope from "../Scope.ts"
 import * as Tracer from "../Tracer.ts"
 import type { ExtractTag } from "../Types.ts"
+import * as Version from "../Version.ts"
 import * as OtlpEnv from "./internal/otlpEnv.ts"
 import * as Exporter from "./OtlpExporter.ts"
 import type { KeyValue, Resource } from "./OtlpResource.ts"
@@ -67,7 +68,8 @@ export const make: (
   const otelResource = yield* OtlpResource.fromConfig(options.resource)
   const serialization = yield* OtlpSerialization
   const scope: Scope = {
-    name: OtlpResource.serviceNameUnsafe(otelResource)
+    name: "effect",
+    version: Version.getCurrentVersion()
   }
 
   const exporter = yield* Exporter.make({
@@ -295,53 +297,44 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
   if (status.exit._tag === "Success") {
     otelStatus = { code: StatusCode.Ok }
   } else if (Cause.hasInterruptsOnly(status.exit.cause)) {
-    otelStatus = {
-      code: StatusCode.Ok,
-      message: "Interrupted"
-    }
+    otelStatus = { code: StatusCode.Unset }
     attributes.push({
-      key: "span.label",
-      value: { stringValue: "⚠︎ Interrupted" }
-    }, {
-      key: "status.interrupted",
+      key: "effect.fiber.interrupted",
       value: { boolValue: true }
     })
   } else {
     const errors = Cause.prettyErrors(status.exit.cause, {
       includeCauseInStack: true
     })
-    otelStatus = {
-      code: StatusCode.Error
-    }
-    if (errors.length > 0) {
-      otelStatus.message = errors[0].message
-      for (const error of errors) {
-        events.push({
-          name: "exception",
-          timeUnixNano: String(status.endTime),
-          droppedAttributesCount: 0,
-          attributes: [
-            {
-              "key": "exception.type",
-              "value": {
-                "stringValue": error.name
-              }
-            },
-            {
-              "key": "exception.message",
-              "value": {
-                "stringValue": error.message
-              }
-            },
-            {
-              "key": "exception.stacktrace",
-              "value": {
-                "stringValue": error.stack ?? "No stack trace available"
-              }
+    otelStatus = errors.length > 0
+      ? { code: StatusCode.Error, message: errors[0].message }
+      : { code: StatusCode.Ok }
+    for (const error of errors) {
+      events.push({
+        name: "exception",
+        timeUnixNano: String(status.endTime),
+        droppedAttributesCount: 0,
+        attributes: [
+          {
+            "key": "exception.type",
+            "value": {
+              "stringValue": error.name
             }
-          ]
-        })
-      }
+          },
+          {
+            "key": "exception.message",
+            "value": {
+              "stringValue": error.message
+            }
+          },
+          {
+            "key": "exception.stacktrace",
+            "value": {
+              "stringValue": error.stack ?? "No stack trace available"
+            }
+          }
+        ]
+      })
     }
   }
 
@@ -413,6 +406,7 @@ export interface ScopeSpan {
 
 interface Scope {
   readonly name: string
+  readonly version?: string
 }
 
 interface OtlpSpan {

package/src/observability/internal/otlpProtobuf.ts

@@ -493,6 +493,62 @@ export const encodeHistogram = (histogram: {
     Proto.varintField(2, histogram.aggregationTemporality)
   )
 
+/**
+ * Encodes a SummaryDataPoint message.
+ *
+ * message SummaryDataPoint {
+ *   repeated KeyValue attributes = 7;
+ *   fixed64 start_time_unix_nano = 2;
+ *   fixed64 time_unix_nano = 3;
+ *   fixed64 count = 4;
+ *   double sum = 5;
+ *   repeated ValueAtQuantile quantile_values = 6;
+ *   uint32 flags = 8;
+ * }
+ *
+ * message ValueAtQuantile {
+ *   double quantile = 1;
+ *   double value = 2;
+ * }
+ *
+ * @internal
+ */
+export const encodeSummaryDataPoint = (point: {
+  readonly attributes: ReadonlyArray<KeyValue>
+  readonly startTimeUnixNano: string
+  readonly timeUnixNano: string
+  readonly count: string | number | bigint
+  readonly sum: number
+  readonly quantileValues: ReadonlyArray<{ readonly quantile: number; readonly value: number }>
+  readonly flags?: number | undefined
+}): Uint8Array =>
+  Proto.concat(
+    Proto.fixed64Field(2, BigInt(point.startTimeUnixNano)),
+    Proto.fixed64Field(3, BigInt(point.timeUnixNano)),
+    Proto.fixed64Field(4, BigInt(point.count)),
+    Proto.doubleField(5, point.sum),
+    Proto.repeatedField(
+      6,
+      point.quantileValues,
+      (q) => Proto.concat(Proto.doubleField(1, q.quantile), Proto.doubleField(2, q.value))
+    ),
+    Proto.repeatedField(7, point.attributes, encodeKeyValue),
+    point.flags !== undefined ? Proto.varintField(8, point.flags) : new Uint8Array(0)
+  )
+
+/**
+ * Encodes a Summary message.
+ *
+ * message Summary {
+ *   repeated SummaryDataPoint data_points = 1;
+ * }
+ *
+ * @internal
+ */
+export const encodeSummary = (summary: {
+  readonly dataPoints: ReadonlyArray<Parameters<typeof encodeSummaryDataPoint>[0]>
+}): Uint8Array => Proto.repeatedField(1, summary.dataPoints, encodeSummaryDataPoint)
+
 /**
  * Encodes a Metric message.
  *
@@ -518,6 +574,7 @@ export const encodeMetric = (metric: {
   readonly gauge?: Parameters<typeof encodeGauge>[0] | undefined
   readonly sum?: Parameters<typeof encodeSum>[0] | undefined
   readonly histogram?: Parameters<typeof encodeHistogram>[0] | undefined
+  readonly summary?: Parameters<typeof encodeSummary>[0] | undefined
 }): Uint8Array =>
   Proto.concat(
     Proto.stringField(1, metric.name),
@@ -531,6 +588,9 @@ export const encodeMetric = (metric: {
       : new Uint8Array(0),
     metric.histogram !== undefined
       ? Proto.messageField(9, encodeHistogram(metric.histogram))
+      : new Uint8Array(0),
+    metric.summary !== undefined
+      ? Proto.messageField(11, encodeSummary(metric.summary))
       : new Uint8Array(0)
   )
 

package/src/reactivity/AsyncResult.ts

@@ -644,7 +644,7 @@ export const flatMap: {
    * @category combinators
    * @since 4.0.0
    */
-  <A, E, B, E2>(f: (a: A, prev: Success<A, E>) => AsyncResult<A, E2>): (self: AsyncResult<A, E>) => AsyncResult<B, E | E2>
+  <A, E, B, E2>(f: (a: A, prev: Success<A, E>) => AsyncResult<B, E2>): (self: AsyncResult<A, E>) => AsyncResult<B, E | E2>
   /**
    * Maps the success value of an `AsyncResult` and flattens the result.
    *

package/src/reactivity/Atom.ts

@@ -818,7 +818,7 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
       | ((
         get: AtomContext
       ) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>)
-  ) => Writable<AsyncResult.AsyncResult<A, E>, A>
+  ) => Writable<AsyncResult.AsyncResult<A, E | ER>, A>
 }
 
 /**
@@ -2774,18 +2774,21 @@ export const batch: (f: () => void) => void = Registry.batch
 // -----------------------------------------------------------------------------
 
 /**
- * Creates a browser-only signal atom that increments when the document becomes visible.
+ * Creates a signal atom that increments when the document becomes visible.
  *
  * **Details**
  *
  * It listens for `visibilitychange` events on `window` and removes the listener
- * when the atom is disposed.
+ * when the atom is disposed. Without `window`, it stays at `0` and adds no listener.
  *
  * @stability unstable
  * @category constants
  * @since 4.0.0
  */
 export const windowFocusSignal: Atom<number> = readable((get) => {
+  if (typeof window === "undefined") {
+    return 0
+  }
   let count = 0
   function update() {
     if (document.visibilityState === "visible") {
@@ -2825,8 +2828,8 @@ export const makeRefreshOnSignal = <_>(signal: Atom<_>) => <A extends Atom<any>>
  *
  * **Details**
  *
- * This helper is browser-only because `windowFocusSignal` depends on `window` and
- * `document.visibilityState`.
+ * Without `window`, this helper does not trigger refreshes. Source atom updates
+ * are still forwarded.
  *
  * @stability unstable
  * @category combinators
@@ -2991,7 +2994,8 @@ function updateSearchParams() {
     }
   }
   searchParamState.updates.clear()
-  const newUrl = `${window.location.pathname}?${searchParams.toString()}`
+  const search = searchParams.toString()
+  const newUrl = `${window.location.pathname}${search.length > 0 ? `?${search}` : ""}${window.location.hash}`
   window.history.pushState({}, "", newUrl)
   searchParamState.updating = false
 }

package/src/reactivity/AtomHttpApi.ts

@@ -57,7 +57,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       HttpApiGroup.Endpoints<Group>,
       EndpointIdentifier
     >,
-    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = HttpApiEndpoint.ClientResponseMode
+    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = "decoded-only"
   >(
     group: GroupIdentifier,
     endpoint: EndpointIdentifier,
@@ -353,9 +353,7 @@ type ResponseByMode<
   Endpoint extends HttpApiEndpoint.Constraint,
   ResponseMode extends HttpApiEndpoint.ClientResponseMode
 > = HttpApiClient.Client.Response<
-  Effect.Success<
-    ReturnType<HttpApiClient.Client.Method<Extract<Endpoint, HttpApiEndpoint.ConstraintRequest>, never, never>>
-  >,
+  HttpApiClient.SuccessType<Extract<Endpoint, HttpApiEndpoint.ConstraintRequest>["~Success"]>,
   ResponseMode
 >
 

package/src/reactivity/AtomRegistry.ts

@@ -71,11 +71,13 @@ export interface AtomRegistry {
   readonly scheduler: Scheduler
   readonly schedulerAsync: Scheduler
   readonly getNodes: () => ReadonlyMap<Atom.Atom<any> | string, Node<any>>
+  readonly ensureNode: <A>(atom: Atom.Atom<A>) => Node<A>
   readonly get: <A>(atom: Atom.Atom<A>) => A
   readonly mount: <A>(atom: Atom.Atom<A>) => () => void
   readonly refresh: <A>(atom: Atom.Atom<A>) => void
   readonly set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void
   readonly setSerializable: (key: string, encoded: unknown) => void
+  readonly preloadedSerializable: Map<string, unknown>
   readonly modify: <R, W, A>(atom: Atom.Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]) => A
   readonly update: <R, W>(atom: Atom.Writable<R, W>, f: (_: R) => W) => void
   readonly subscribe: <A>(atom: Atom.Atom<A>, f: (_: A) => void, options?: {
@@ -83,6 +85,7 @@ export interface AtomRegistry {
   }) => () => void
   readonly reset: () => void
   readonly dispose: () => void
+  scheduleNodeRemoval(node: Node<any>): void
   onNodeAdded?: ((node: Node<any>) => void) | undefined
   onNodeRemoved?: ((node: Node<any>) => void) | undefined
 }
@@ -102,10 +105,14 @@ export interface AtomRegistry {
 export interface Node<A> {
   readonly atom: Atom.Atom<A>
   readonly value: () => A
+  readonly valueOption: () => Option.Option<A>
+  readonly canBeRemoved: boolean
   parents: Set<Node<any>>
   children: Set<Node<any>>
   listeners: Set<() => void>
   currentState(): "uninitialized" | "stale" | "valid" | "removed"
+  setInitialValue(value: A): void
+  subscribe(listener: () => void): () => void
 }
 
 /**