effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/net/index.ts

@@ -0,0 +1,20 @@
+/**
+ * @since 4.0.0
+ */
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @since 4.0.0
+ */
+export * as IpInterface from "./IpInterface.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as IpNetwork from "./IpNetwork.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as NetAddress from "./NetAddress.ts"

package/src/unstable/observability/OtlpExporter.ts

@@ -167,6 +167,7 @@ export const make: (
     readonly label: string
     readonly exportInterval: Duration.Input
     readonly maxBatchSize: number | "disabled"
+    readonly exportEmpty?: boolean | undefined
     readonly body: (data: Array<any>) => readonly [body: HttpBody, onSuccess: Effect.Effect<void>]
     readonly shutdownTimeout: Duration.Input
   }
@@ -201,13 +202,11 @@ export const make: (
     } else if (disabledUntil !== undefined) {
       disabledUntil = undefined
     }
-    const items = buffer
-    if (options.maxBatchSize !== "disabled") {
-      if (buffer.length === 0) {
-        return Effect.void
-      }
-      buffer = []
+    if (buffer.length === 0 && (options.maxBatchSize !== "disabled" || options.exportEmpty !== true)) {
+      return Effect.void
     }
+    const items = buffer
+    buffer = []
     const [body, onSuccess] = options.body(items)
     return client.execute(
       HttpClientRequest.setBody(request, body)

package/src/unstable/observability/OtlpLogger.ts

@@ -141,7 +141,7 @@ export const layerFromConfig = (options?: {
 }): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
   Effect.gen(function*() {
     const { disabled, endpoint, exporters } = yield* Config.all({
-      disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
+      disabled: Config.Boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
       endpoint: OtlpEnv.endpoint("LOGS"),
       exporters: OtlpEnv.exporters("LOGS")
     })
@@ -151,11 +151,11 @@ export const layerFromConfig = (options?: {
     }
 
     const { baseTimeout, logsTimeout, exportTimeout, scheduleDelay, maxBatchSize } = yield* Config.all({
-      baseTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TIMEOUT")),
-      logsTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_LOGS_TIMEOUT")),
-      exportTimeout: Config.option(Config.int("OTEL_BLRP_EXPORT_TIMEOUT")),
-      scheduleDelay: Config.option(Config.int("OTEL_BLRP_SCHEDULE_DELAY")),
-      maxBatchSize: Config.option(Config.int("OTEL_BLRP_MAX_EXPORT_BATCH_SIZE"))
+      baseTimeout: Config.option(Config.Int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+      logsTimeout: Config.option(Config.Int("OTEL_EXPORTER_OTLP_LOGS_TIMEOUT")),
+      exportTimeout: Config.option(Config.Int("OTEL_BLRP_EXPORT_TIMEOUT")),
+      scheduleDelay: Config.option(Config.Int("OTEL_BLRP_SCHEDULE_DELAY")),
+      maxBatchSize: Config.option(Config.Int("OTEL_BLRP_MAX_EXPORT_BATCH_SIZE"))
     })
 
     const shutdownTimeout = Option.firstSomeOf([logsTimeout, baseTimeout, exportTimeout]).pipe(
@@ -227,9 +227,9 @@ const makeLogRecord = (options: Logger.Options<unknown>, opts: {
     droppedAttributesCount: 0
   }
 
-  if (options.fiber.currentSpan) {
-    logRecord.traceId = options.fiber.currentSpan.traceId
-    logRecord.spanId = options.fiber.currentSpan.spanId
+  if (options.fiber.cache.span) {
+    logRecord.traceId = options.fiber.cache.span.traceId
+    logRecord.spanId = options.fiber.cache.span.spanId
   }
 
   return logRecord

package/src/unstable/observability/OtlpMetrics.ts

@@ -156,7 +156,7 @@ export const make: (options: {
               if (typeof currentCount === "bigint" && typeof previousCount === "bigint") {
                 reportValue = currentCount - previousCount
                 // Handle reset: if current < previous, report current value
-                if (reportValue < BigInt(0)) {
+                if (state.state.incremental && reportValue < BigInt(0)) {
                   reportValue = currentCount
                 }
               } else {
@@ -164,7 +164,7 @@ export const make: (options: {
                 const prev = Number(previousCount)
                 reportValue = curr - prev
                 // Handle reset
-                if (reportValue < 0) {
+                if (state.state.incremental && reportValue < 0) {
                   reportValue = curr
                 }
               }
@@ -461,6 +461,7 @@ export const make: (options: {
     url: options.url,
     headers: options.headers,
     maxBatchSize: "disabled",
+    exportEmpty: true,
     exportInterval: options.exportInterval ?? Duration.seconds(10),
     body: snapshot,
     shutdownTimeout: options.shutdownTimeout ?? Duration.seconds(3)
@@ -503,7 +504,7 @@ export const layerFromConfig = (options?: {
 }): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
   Effect.gen(function*() {
     const { disabled, endpoint, exporters } = yield* Config.all({
-      disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
+      disabled: Config.Boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
       endpoint: OtlpEnv.endpoint("METRICS"),
       exporters: OtlpEnv.exporters("METRICS")
     })
@@ -512,16 +513,16 @@ export const layerFromConfig = (options?: {
     }
 
     const { baseTimeout, metricsTimeout, exportTimeout, exportInterval, temporalityPreference } = yield* Config.all({
-      baseTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TIMEOUT")),
-      metricsTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_METRICS_TIMEOUT")),
-      exportTimeout: Config.option(Config.int("OTEL_METRIC_EXPORT_TIMEOUT")),
+      baseTimeout: Config.option(Config.Int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+      metricsTimeout: Config.option(Config.Int("OTEL_EXPORTER_OTLP_METRICS_TIMEOUT")),
+      exportTimeout: Config.option(Config.Int("OTEL_METRIC_EXPORT_TIMEOUT")),
       exportInterval: Config.option(
-        Config.int("OTEL_METRIC_EXPORT_INTERVAL").pipe(
+        Config.Int("OTEL_METRIC_EXPORT_INTERVAL").pipe(
           Config.map(Duration.millis)
         )
       ),
       temporalityPreference: Config.option(
-        Config.literals(["delta", "cumulative"], "OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE")
+        Config.Literals(["delta", "cumulative"], "OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE")
       )
     })
 

package/src/unstable/observability/OtlpResource.ts

@@ -99,16 +99,17 @@ export const fromConfig: (
   readonly serviceVersion?: string | undefined
   readonly attributes?: Record<string, unknown> | undefined
 }) {
-  const env = yield* Config.schema(
-    Schema.UndefinedOr(Config.Record(Schema.StringFromUriComponent, Schema.StringFromUriComponent)),
+  const env = yield* Config.Record(
+    Schema.StringFromUriComponent,
+    Schema.StringFromUriComponent,
     "OTEL_RESOURCE_ATTRIBUTES"
-  )
+  ).pipe(Config.withDefault(undefined))
 
   const serviceName = options?.serviceName
     ?? options?.attributes?.["service.name"] as string | undefined
     ?? (yield* Config.schema(Schema.UndefinedOr(Schema.String), "OTEL_SERVICE_NAME"))
     ?? env?.["service.name"] as string | undefined
-    ?? (yield* Config.string("OTEL_SERVICE_NAME"))
+    ?? (yield* Config.String("OTEL_SERVICE_NAME"))
 
   const serviceVersion = options?.serviceVersion
     ?? options?.attributes?.["service.version"] as string | undefined

package/src/unstable/observability/OtlpTracer.ts

@@ -22,7 +22,7 @@ import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
 import * as Tracer from "../../Tracer.ts"
-import type { ExtractTag, Mutable } from "../../Types.ts"
+import type { ExtractTag } from "../../Types.ts"
 import type * as Headers from "../http/Headers.ts"
 import type * as HttpClient from "../http/HttpClient.ts"
 import * as OtlpEnv from "./internal/otlpEnv.ts"
@@ -96,22 +96,14 @@ export const make: (
 
   return Tracer.make({
     span(options) {
-      return makeSpan({
-        ...options,
-        status: {
-          _tag: "Started",
-          startTime: options.startTime
-        },
-        attributes: new Map(),
-        export: exportFn
-      })
+      return new SpanImpl(options, exportFn)
     },
     context: options.context ?
       function(primitive, fiber) {
-        if (fiber.currentSpan === undefined) {
+        if (fiber.cache.span === undefined) {
           return primitive["~effect/Effect/evaluate"](fiber)
         }
-        return options.context!(primitive, fiber.currentSpan)
+        return options.context!(primitive, fiber.cache.span)
       } :
       undefined
   })
@@ -158,7 +150,7 @@ export const layerFromConfig = (options?: {
 }): Layer.Layer<Exporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization> =>
   Effect.gen(function*() {
     const { disabled, endpoint, exporters } = yield* Config.all({
-      disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
+      disabled: Config.Boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
       endpoint: OtlpEnv.endpoint("TRACES"),
       exporters: OtlpEnv.exporters("TRACES")
     })
@@ -168,15 +160,15 @@ export const layerFromConfig = (options?: {
     }
 
     const { baseTimeout, tracesTimeout, exportTimeout, scheduleDelay, maxBatchSize } = yield* Config.all({
-      baseTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TIMEOUT")),
-      tracesTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TRACES_TIMEOUT")),
-      exportTimeout: Config.option(Config.int("OTEL_BSP_EXPORT_TIMEOUT")),
+      baseTimeout: Config.option(Config.Int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+      tracesTimeout: Config.option(Config.Int("OTEL_EXPORTER_OTLP_TRACES_TIMEOUT")),
+      exportTimeout: Config.option(Config.Int("OTEL_BSP_EXPORT_TIMEOUT")),
       scheduleDelay: Config.option(
-        Config.int("OTEL_BSP_SCHEDULE_DELAY").pipe(
+        Config.Int("OTEL_BSP_SCHEDULE_DELAY").pipe(
           Config.map(Duration.millis)
         )
       ),
-      maxBatchSize: Config.option(Config.int("OTEL_BSP_MAX_EXPORT_BATCH_SIZE"))
+      maxBatchSize: Config.option(Config.Int("OTEL_BSP_MAX_EXPORT_BATCH_SIZE"))
     })
 
     const shutdownTimeout = Option.firstSomeOf([tracesTimeout, baseTimeout, exportTimeout]).pipe(
@@ -196,17 +188,64 @@ export const layerFromConfig = (options?: {
 
 // internal
 
-interface SpanImpl extends Tracer.Span {
-  readonly export: (span: SpanImpl) => void
-  readonly attributes: Map<string, unknown>
+class SpanImpl implements Tracer.Span {
+  readonly _tag = "Span"
+  readonly name: string
+  readonly parent: Option.Option<Tracer.AnySpan>
+  readonly annotations: Context.Context<never>
   readonly links: Array<Tracer.SpanLink>
-  readonly events: Array<[name: string, startTime: bigint, attributes: Record<string, unknown> | undefined]>
+  readonly kind: Tracer.SpanKind
+  readonly sampled: boolean
+  readonly export: (span: SpanImpl) => void
   status: Tracer.SpanStatus
-}
+  _traceId: string | undefined = undefined
+  _spanId: string | undefined = undefined
+  _attributes: Map<string, unknown> | undefined = undefined
+  _events: Array<[name: string, startTime: bigint, attributes: Record<string, unknown> | undefined]> | undefined =
+    undefined
+
+  constructor(
+    options: {
+      readonly name: string
+      readonly parent: Option.Option<Tracer.AnySpan>
+      readonly annotations: Context.Context<never>
+      readonly links: Array<Tracer.SpanLink>
+      readonly startTime: bigint
+      readonly kind: Tracer.SpanKind
+      readonly sampled: boolean
+    },
+    exportFn: (span: SpanImpl) => void
+  ) {
+    this.name = options.name
+    this.parent = options.parent
+    this.annotations = options.annotations
+    this.links = options.links
+    this.kind = options.kind
+    this.sampled = options.sampled
+    this.export = exportFn
+    this.status = {
+      _tag: "Started",
+      startTime: options.startTime
+    }
+  }
+
+  get traceId(): string {
+    return this._traceId ??= Option.isSome(this.parent) ? this.parent.value.traceId : Encoding.randomHex(32)
+  }
+
+  get spanId(): string {
+    return this._spanId ??= Encoding.randomHex(16)
+  }
+
+  get attributes(): Map<string, unknown> {
+    return this._attributes ??= new Map()
+  }
 
-const SpanProto = {
-  _tag: "Span",
-  end(this: SpanImpl, endTime: bigint, exit: Exit.Exit<unknown, unknown>) {
+  get events(): Array<[name: string, startTime: bigint, attributes: Record<string, unknown> | undefined]> {
+    return this._events ??= []
+  }
+
+  end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void {
     this.status = {
       _tag: "Ended",
       startTime: this.status.startTime,
@@ -214,59 +253,43 @@ const SpanProto = {
       exit
     }
     this.export(this)
-  },
-  attribute(this: SpanImpl, key: string, value: unknown) {
+  }
+
+  attribute(key: string, value: unknown): void {
     this.attributes.set(key, value)
-  },
-  event(this: SpanImpl, name: string, startTime: bigint, attributes?: Record<string, unknown>) {
+  }
+
+  event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void {
     this.events.push([name, startTime, attributes])
-  },
-  addLinks(this: SpanImpl, links: ReadonlyArray<Tracer.SpanLink>) {
-    this.links.push(...links)
   }
-}
-type RemainingSpanImpl = Omit<Tracer.Span, (keyof typeof SpanProto) | "traceId" | "spanId" | "events">
 
-const makeSpan = (options: {
-  readonly name: string
-  readonly parent: Option.Option<Tracer.AnySpan>
-  readonly annotations: Context.Context<never>
-  readonly status: Tracer.SpanStatus
-  readonly attributes: ReadonlyMap<string, unknown>
-  readonly links: ReadonlyArray<Tracer.SpanLink>
-  readonly kind: Tracer.SpanKind
-  readonly sampled: boolean
-  readonly export: (span: SpanImpl) => void
-}): SpanImpl => {
-  const self: Mutable<SpanImpl> = Object.assign(
-    Object.create(SpanProto),
-    options satisfies RemainingSpanImpl
-  )
-  if (Option.isSome(self.parent)) {
-    self.traceId = self.parent.value.traceId
-  } else {
-    self.traceId = Encoding.randomHex(32)
+  addLinks(links: ReadonlyArray<Tracer.SpanLink>): void {
+    // oxlint-disable-next-line no-restricted-syntax
+    this.links.push(...links)
   }
-  self.spanId = Encoding.randomHex(16)
-  self.events = []
-  return self
 }
 
 const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
   const status = self.status as ExtractTag<Tracer.SpanStatus, "Ended">
-  const attributes = entriesToAttributes(self.attributes.entries())
-  const events = self.events.map(([name, startTime, attributes]) => ({
-    name,
-    timeUnixNano: String(startTime),
-    attributes: attributes
-      ? entriesToAttributes(Object.entries(attributes))
-      : [],
-    droppedAttributesCount: 0
-  }))
+  const attributes = self._attributes === undefined ? [] : entriesToAttributes(self._attributes)
+  const events: Array<Event> = []
+  if (self._events !== undefined) {
+    for (let i = 0; i < self._events.length; i++) {
+      const [name, startTime, attributes] = self._events[i]
+      events.push({
+        name,
+        timeUnixNano: String(startTime),
+        attributes: attributes
+          ? entriesToAttributes(Object.entries(attributes))
+          : [],
+        droppedAttributesCount: 0
+      })
+    }
+  }
   let otelStatus: Status
 
   if (status.exit._tag === "Success") {
-    otelStatus = constOtelStatusSuccess
+    otelStatus = { code: StatusCode.Ok }
   } else if (Cause.hasInterruptsOnly(status.exit.cause)) {
     otelStatus = {
       code: StatusCode.Ok,
@@ -318,13 +341,21 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
     }
   }
 
+  const links: Array<Link> = []
+  for (let i = 0; i < self.links.length; i++) {
+    const link = self.links[i]
+    links.push({
+      traceId: link.span.traceId,
+      spanId: link.span.spanId,
+      attributes: entriesToAttributes(Object.entries(link.attributes)),
+      droppedAttributesCount: 0
+    })
+  }
+
   return {
     traceId: self.traceId,
     spanId: self.spanId,
-    parentSpanId: Option.match(self.parent, {
-      onNone: () => undefined,
-      onSome: (parent) => parent.spanId
-    }),
+    parentSpanId: Option.isSome(self.parent) ? self.parent.value.spanId : undefined,
     name: self.name,
     kind: SpanKind[self.kind],
     startTimeUnixNano: String(status.startTime),
@@ -334,12 +365,7 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
     events,
     droppedEventsCount: 0,
     status: otelStatus,
-    links: self.links.map((link) => ({
-      traceId: link.span.traceId,
-      spanId: link.span.spanId,
-      attributes: entriesToAttributes(Object.entries(link.attributes)),
-      droppedAttributesCount: 0
-    })),
+    links,
     droppedLinksCount: 0
   }
 }
@@ -434,7 +460,3 @@ const SpanKind = {
   producer: 4,
   consumer: 5
 } as const
-
-const constOtelStatusSuccess: Status = {
-  code: StatusCode.Ok
-}

package/src/unstable/observability/internal/otlpEnv.ts

@@ -1,28 +1,25 @@
 import * as Config from "../../../Config.ts"
 import * as Schema from "../../../Schema.ts"
-import * as SchemaGetter from "../../../SchemaGetter.ts"
 
 export type Signal = "LOGS" | "METRICS" | "TRACES"
 
-const ExporterList = Config.Array(Schema.String).pipe(
-  Schema.decode({
-    decode: SchemaGetter.transform((_) => _.map((_) => _.toLowerCase().trim()).filter((_) => _ !== "")),
-    encode: SchemaGetter.passthrough()
-  })
-)
+const exporterList = (path: string) =>
+  Config.Array(Schema.String, path).pipe(
+    Config.map((_) => _.map((_) => _.toLowerCase().trim()).filter((_) => _ !== ""))
+  )
 
-const HeadersRecord = Config.Record(Schema.String, Schema.StringFromUriComponent)
+const headersRecord = (path: string) => Config.Record(Schema.String, Schema.StringFromUriComponent, path)
 
 export const headers = (signal: Signal) =>
-  Config.schema(HeadersRecord, `OTEL_EXPORTER_OTLP_${signal}_HEADERS`).pipe(
-    Config.orElse(() => Config.schema(HeadersRecord, "OTEL_EXPORTER_OTLP_HEADERS")),
+  headersRecord(`OTEL_EXPORTER_OTLP_${signal}_HEADERS`).pipe(
+    Config.orElse(() => headersRecord("OTEL_EXPORTER_OTLP_HEADERS")),
     Config.withDefault(undefined)
   )
 
 export const endpoint = (signal: Signal) =>
-  Config.url(`OTEL_EXPORTER_OTLP_${signal}_ENDPOINT`).pipe(
+  Config.URL(`OTEL_EXPORTER_OTLP_${signal}_ENDPOINT`).pipe(
     Config.orElse(() =>
-      Config.url("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(
+      Config.URL("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(
         Config.map((url) => {
           const slash = url.pathname.endsWith("/") ? "" : "/"
           url.pathname += `${slash}v1/${signal.toLowerCase()}`
@@ -34,6 +31,6 @@ export const endpoint = (signal: Signal) =>
   )
 
 export const exporters = (signal: Signal) =>
-  Config.schema(ExporterList, `OTEL_${signal}_EXPORTER`).pipe(
+  exporterList(`OTEL_${signal}_EXPORTER`).pipe(
     Config.withDefault<ReadonlyArray<string>>([])
   )

package/src/unstable/persistence/PersistedCache.ts

@@ -92,7 +92,7 @@ export const make: <
       if (exit) {
         return yield* exit
       }
-      const result = yield* Effect.exit(lookup(key))
+      const result = yield* Effect.exit(Effect.suspend(() => lookup(key)))
       yield* (store.set(key, result) as Effect.Effect<void>)
       return yield* result
     }),