effect 4.0.0 → 4.0.2

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -1067,13 +1067,15 @@ function translateJsonSchemaMultiDocument(
         )
       case "ignore":
         return undefined
-      case "apply":
+      case "apply": {
+        let regex: RegExp
         try {
-          globalThis.RegExp(pattern, jsonSchemaPatternFlags)
+          regex = globalThis.RegExp(pattern, jsonSchemaPatternFlags)
         } catch {
           throw errorWithPath("Cannot import pattern using ECMAScript Unicode mode.", path)
         }
-        return jsonSchemaFilter("effect/schema/isPattern", { source: pattern, flags: jsonSchemaPatternFlags })
+        return jsonSchemaFilter("effect/schema/isPattern", { source: regex.source, flags: regex.flags })
+      }
     }
   }
 

package/src/internal/schema/standardSchema.ts

@@ -53,7 +53,7 @@ export function toStandardSchemaV1<S extends Schema.ConstraintDecoder<unknown>>(
       })
     })
   }
-  if ("~standard" in self) {
+  if (Object.hasOwn(self, "~standard")) {
     const out = self as any
     if ("validate" in out["~standard"]) return out
     Object.assign(out["~standard"], { validate })
@@ -109,7 +109,7 @@ export function toStandardJSONSchemaV1<S extends Schema.Constraint>(
       return toBaseStandardJSONSchemaV1(SchemaAST.toType(self.ast), options.target)
     }
   }
-  if ("~standard" in self) {
+  if (Object.hasOwn(self, "~standard")) {
     const out = self as any
     if ("jsonSchema" in out["~standard"]) return out
     Object.assign(out["~standard"], { jsonSchema })

package/src/internal/version.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export const version = "4.0.2"

package/src/observability/OtlpExporter.ts

@@ -26,6 +26,7 @@ import * as Num from "../Number.ts"
 import * as Option from "../Option.ts"
 import * as Schedule from "../Schedule.ts"
 import * as Scope from "../Scope.ts"
+import * as Version from "../Version.ts"
 
 const retryAfterDelay = (value: string | undefined): Effect.Effect<Duration.Duration> => {
   const seconds = Option.fromUndefinedOr(value).pipe(Option.flatMap(Num.parse))
@@ -194,12 +195,14 @@ export const make: (
     HttpClient.retryTransient({ schedule: policy, times: 3 })
   )
 
-  let headers = Headers.fromRecordUnsafe({
-    "user-agent": `effect-opentelemetry-${options.label}/0.0.0`
-  })
-  if (options.headers) {
-    headers = Headers.merge(Headers.fromInput(options.headers), headers)
-  }
+  const exporterUserAgent = `OTel-OTLP-Exporter-JavaScript-Effect-${options.label}/${Version.getCurrentVersion()}`
+  const userHeaders = Headers.fromInput(options.headers)
+  const userAgent = userHeaders["user-agent"]
+  const headers = Headers.set(
+    userHeaders,
+    "user-agent",
+    userAgent ? `${userAgent} ${exporterUserAgent}` : exporterUserAgent
+  )
 
   const request = HttpClientRequest.post(options.url, { headers })
   let buffer: Array<any> = []

package/src/observability/OtlpLogger.ts

@@ -23,6 +23,7 @@ import type * as LogLevel from "../LogLevel.ts"
 import * as Option from "../Option.ts"
 import { CurrentLogAnnotations, CurrentLogSpans } from "../References.ts"
 import type * as Scope from "../Scope.ts"
+import * as Version from "../Version.ts"
 import * as OtlpEnv from "./internal/otlpEnv.ts"
 import * as Exporter from "./OtlpExporter.ts"
 import type { AnyValue, Fixed64, KeyValue, Resource } from "./OtlpResource.ts"
@@ -64,7 +65,8 @@ export const make: (
   const serialization = yield* OtlpSerialization
   const otelResource = yield* OtlpResource.fromConfig(options.resource)
   const scope: IInstrumentationScope = {
-    name: OtlpResource.serviceNameUnsafe(otelResource)
+    name: "effect",
+    version: Version.getCurrentVersion()
   }
 
   const exporter = yield* Exporter.make({
@@ -192,32 +194,29 @@ export interface LogsData {
 
 // internal
 
+const nanosPerMilli = BigInt(1_000_000)
+
 const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   readonly excludeLogSpans: boolean
   readonly clock: Clock
 }): ILogRecord => {
-  const now = opts.clock.currentTimeNanosUnsafe()
-  const nanosString = now.toString()
-  const nowMillis = options.date.getTime()
+  const observedTime = opts.clock.currentTimeNanosUnsafe().toString()
+  const eventMillis = options.date.getTime()
+  const eventTime = (BigInt(eventMillis) * nanosPerMilli).toString()
 
-  const attributes = OtlpResource.entriesToAttributes(Object.entries(options.fiber.getRef(CurrentLogAnnotations)))
-  attributes.push({
-    key: "fiberId",
-    value: { intValue: options.fiber.id }
-  })
+  const attributes: Record<string, unknown> = { ...options.fiber.getRef(CurrentLogAnnotations) }
+  attributes["effect.fiberId"] = options.fiber.id
   if (!opts.excludeLogSpans) {
+    // Outermost spans win duplicate labels.
     for (const [label, startTime] of options.fiber.getRef(CurrentLogSpans)) {
-      attributes.push({
-        key: `logSpan.${label}`,
-        value: { stringValue: `${nowMillis - startTime}ms` }
-      })
+      attributes[`effect.log_span.${label}`] = eventMillis - startTime
     }
   }
-  if (options.cause.reasons.length > 0) {
-    attributes.push({
-      key: "log.error",
-      value: { stringValue: Cause.pretty(options.cause) }
-    })
+  const errors = Cause.prettyErrors(options.cause, { includeCauseInStack: true })
+  if (errors.length > 0) {
+    attributes["exception.type"] = errors[0].name
+    attributes["exception.message"] = errors[0].message
+    attributes["exception.stacktrace"] = errors.map((error) => error.stack).join("\n")
   }
 
   const message = Arr.ensure(options.message)
@@ -225,9 +224,9 @@ const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   const logRecord: ILogRecord = {
     severityNumber: logLevelToSeverityNumber(options.logLevel),
     severityText: options.logLevel,
-    timeUnixNano: nanosString,
-    observedTimeUnixNano: nanosString,
-    attributes,
+    timeUnixNano: eventTime,
+    observedTimeUnixNano: observedTime,
+    attributes: OtlpResource.entriesToAttributes(Object.entries(attributes)),
     body: OtlpResource.unknownToAttributeValue(message.length === 1 ? message[0] : message),
     droppedAttributesCount: 0
   }

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.
    *