effect 4.0.1 → 4.0.3

package/src/net/index.ts

@@ -5,6 +5,24 @@
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as AddressResolver from "./AddressResolver.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as Dns from "./Dns.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as Host from "./Host.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0

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

@@ -12,7 +12,6 @@
  * @stability unstable
  * @since 4.0.0
  */
-import * as Arr from "../Array.ts"
 import { Clock } from "../Clock.ts"
 import * as Config from "../Config.ts"
 import * as Duration from "../Duration.ts"
@@ -39,6 +38,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 +115,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 +126,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 +143,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 +180,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 +208,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
           }
@@ -228,27 +227,24 @@ export const make: (options: {
           break
         }
         case "Histogram": {
-          const size = state.state.buckets.length
           const currentBuckets = {
-            boundaries: Arr.allocate(size - 1) as Array<number>,
-            counts: Arr.allocate(size) as Array<number>
+            boundaries: [] as Array<number>,
+            counts: [] as Array<number>
           }
-          let idx = 0
           let prev = 0
           for (const [boundary, value] of state.state.buckets) {
-            if (idx < size - 1) {
-              currentBuckets.boundaries[idx] = boundary
-            }
-            currentBuckets.counts[idx] = value - prev
+            if (boundary === Number.POSITIVE_INFINITY) break
+            currentBuckets.boundaries.push(boundary)
+            currentBuckets.counts.push(value - prev)
             prev = value
-            idx++
           }
+          // Derive overflow from the total count, whether or not boundaries include Infinity.
+          currentBuckets.counts.push(state.state.count - prev)
 
           let reportCount = state.state.count
           let reportSum = state.state.sum
           let reportBucketCounts = currentBuckets.counts
-          const reportMin = state.state.min
-          const reportMax = state.state.max
+          let reportExtrema = true
 
           if (isDelta) {
             const previousState = previousHistogramState.get(metricKey)
@@ -258,17 +254,13 @@ export const make: (options: {
               reportBucketCounts = currentBuckets.counts.map((c, i) =>
                 Math.max(0, c - (previousState.bucketCounts[i] ?? 0))
               )
-              // For delta, min/max represent the interval's min/max
-              // We can't compute these from cumulative state, so we use current values
-              // Note: This is a limitation - true delta min/max would require tracking
-              // observations within each interval
+              // Cumulative extrema cannot describe a later delta interval.
+              reportExtrema = false
             }
             nextHistogramState.set(metricKey, {
               count: state.state.count,
               sum: state.state.sum,
-              bucketCounts: currentBuckets.counts.slice(),
-              min: state.state.min,
-              max: state.state.max
+              bucketCounts: currentBuckets.counts.slice()
             })
           }
 
@@ -277,8 +269,7 @@ export const make: (options: {
             startTimeUnixNano: intervalStartTime,
             timeUnixNano: nowTime,
             count: reportCount,
-            min: reportMin,
-            max: reportMax,
+            ...(reportExtrema ? { min: state.state.min, max: state.state.max } : undefined),
             sum: reportSum,
             bucketCounts: reportBucketCounts,
             explicitBounds: currentBuckets.boundaries
@@ -344,91 +335,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 +376,6 @@ export const make: (options: {
         previousCounterState = nextCounterState
         previousHistogramState = nextHistogramState
         previousFrequencyState = nextFrequencyState
-        previousSummaryState = nextSummaryState
         previousExportTimeNanos = nowNanos
         committedSnapshotSequence = currentSnapshotSequence
       })
@@ -567,19 +491,25 @@ 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
   readonly sum: number
   readonly bucketCounts: Array<number>
-  readonly min: number
-  readonly max: number
-}
-
-/** Previous state for summary delta computation */
-interface PreviousSummaryState {
-  readonly count: number
-  readonly sum: number
 }
 
 /** Properties of an InstrumentationScope. */
@@ -675,7 +605,7 @@ interface INumberDataPoint {
   /** NumberDataPoint asDouble */
   asDouble?: number | null
   /** NumberDataPoint asInt */
-  asInt?: number
+  asInt?: number | string
   /** NumberDataPoint exemplars */
   exemplars?: Array<IExemplar>
   /** NumberDataPoint flags */
@@ -740,9 +670,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/PrometheusMetrics.ts

@@ -425,6 +425,7 @@ const formatHistogram = (
   // Effect buckets are [boundary, cumulativeCount] pairs
   for (let i = 0; i < state.buckets.length; i++) {
     const [boundary, cumulativeCount] = state.buckets[i]
+    if (boundary === Number.POSITIVE_INFINITY) continue
     const bucketLabels = formatLabels(metric.attributes, [["le", boundary.toString()]])
     lines.push(`${name}_bucket${bucketLabels} ${cumulativeCount}`)
   }