effect 4.0.6 → 4.1.0

package/src/internal/uuid.ts

@@ -18,30 +18,20 @@ export const stringify = (bytes: Uint8Array): string => {
     hex[bytes[10]] + hex[bytes[11]] + hex[bytes[12]] + hex[bytes[13]] + hex[bytes[14]] + hex[bytes[15]]
 }
 
-const randomBytes = (): Uint8Array<ArrayBuffer> => globalThis.crypto.getRandomValues(new Uint8Array(16))
-
-/** @internal */
-export function v4Bytes(): Uint8Array<ArrayBuffer>
-/** @internal */
-export function v4Bytes<A extends ArrayBufferLike>(bytes: Uint8Array<A>): Uint8Array<A>
 /** @internal */
-export function v4Bytes(bytes: Uint8Array = randomBytes()): Uint8Array {
+export const v4Bytes = <A extends ArrayBufferLike>(bytes: Uint8Array<A>): Uint8Array<A> => {
   bytes[6] = (bytes[6] & 0x0f) | 0x40
   bytes[8] = (bytes[8] & 0x3f) | 0x80
   return bytes
 }
 
 /** @internal */
-export const v4String = (bytes?: Uint8Array): string => stringify(bytes === undefined ? v4Bytes() : v4Bytes(bytes))
+export const v4String = (bytes: Uint8Array): string => stringify(v4Bytes(bytes))
 
 const maxV7Timestamp = 2 ** 48 - 1
 
 /** @internal */
-export function v7Bytes(timestampMillis: number): Uint8Array<ArrayBuffer>
-/** @internal */
-export function v7Bytes<A extends ArrayBufferLike>(timestampMillis: number, bytes: Uint8Array<A>): Uint8Array<A>
-/** @internal */
-export function v7Bytes(timestampMillis: number, bytes: Uint8Array = randomBytes()): Uint8Array {
+export const v7Bytes = <A extends ArrayBufferLike>(timestampMillis: number, bytes: Uint8Array<A>): Uint8Array<A> => {
   const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxV7Timestamp)
 
   bytes[0] = Math.floor(timestamp / 2 ** 40)
@@ -55,6 +45,57 @@ export function v7Bytes(timestampMillis: number, bytes: Uint8Array = randomBytes
   return bytes
 }
 
-/** @internal */
-export const v7String = (timestampMillis: number, bytes?: Uint8Array): string =>
-  stringify(bytes === undefined ? v7Bytes(timestampMillis) : v7Bytes(timestampMillis, bytes))
+const clampV7Timestamp = (timestampMillis: number): number =>
+  timestampMillis >= 0 ? Math.min(Math.trunc(timestampMillis), maxV7Timestamp) : 0
+
+const maxV7Counter = 2 ** 42 - 1
+
+/**
+ * Makes a UUIDv7 generator that orders the UUIDs it returns, following RFC
+ * 9562 §6.2 Method 1. A 42-bit counter fills the 12 bits of `rand_a` and the
+ * top 30 bits of `rand_b`; the last 32 bits stay random. The ordering ends at
+ * the maximum timestamp, 2^48 − 1 ms, which counter overflow cannot advance.
+ *
+ * @internal
+ */
+export const makeV7Monotonic = () => {
+  let lastTimestamp = -1
+  let counter = 0
+  return <A extends ArrayBufferLike>(timestampMillis: number, bytes: Uint8Array<A>): Uint8Array<A> => {
+    const timestamp = clampV7Timestamp(timestampMillis)
+    if (timestamp > lastTimestamp) {
+      lastTimestamp = timestamp
+      counter = seedV7Counter(bytes)
+    } else if (counter < maxV7Counter) {
+      // The clock stalled or moved back, so keep the last timestamp.
+      counter++
+    } else {
+      lastTimestamp = Math.min(lastTimestamp + 1, maxV7Timestamp)
+      counter = seedV7Counter(bytes)
+    }
+    v7Bytes(lastTimestamp, bytes)
+    const high = Math.floor(counter / 2 ** 30)
+    const low = counter - high * 2 ** 30
+    bytes[6] = 0x70 | (high >>> 8)
+    bytes[7] = high & 0xff
+    bytes[8] = 0x80 | (low >>> 24)
+    bytes[9] = (low >>> 16) & 0xff
+    bytes[10] = (low >>> 8) & 0xff
+    bytes[11] = low & 0xff
+    return bytes
+  }
+}
+
+// Clears the counter's top bit, so a millisecond has at least 2^41 increments
+// before it overflows.
+const seedV7Counter = (bytes: Uint8Array): number =>
+  (((bytes[6] & 0x07) << 8) | bytes[7]) * 2 ** 30 +
+  (((bytes[8] & 0x3f) << 24) | (bytes[9] << 16) | (bytes[10] << 8) | bytes[11])
+
+/**
+ * The UUIDv7 ordering state shared by every `Date.now()` or `Clock` caller in
+ * the realm that has no `SecureRandom` instance of its own.
+ *
+ * @internal
+ */
+export const v7Monotonic = makeV7Monotonic()

package/src/internal/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.0.6"
+export const version = "4.1.0"

package/src/observability/Otlp.ts

@@ -16,6 +16,7 @@ import type * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientRequest from "../http/HttpClientRequest.ts"
 import * as Layer from "../Layer.ts"
 import type * as Tracer from "../Tracer.ts"
+import type * as OtlpExporter from "./OtlpExporter.ts"
 import * as OtlpLogger from "./OtlpLogger.ts"
 import type { AggregationTemporality } from "./OtlpMetrics.ts"
 import * as OtlpMetrics from "./OtlpMetrics.ts"
@@ -30,6 +31,10 @@ import * as OtlpTracer from "./OtlpTracer.ts"
  * The layer sends data to `/v1/logs`, `/v1/metrics`, and `/v1/traces` below
  * `baseUrl` and requires an `OtlpSerialization` implementation.
  *
+ * The layer provides the `OtlpExporter.Flusher` shared by all three signals,
+ * so one `flush` exports their buffered telemetry, for example before a
+ * serverless instance is suspended.
+ *
  * @stability unstable
  * @category layers
  * @since 4.0.0
@@ -56,7 +61,7 @@ export const layer = (options: {
   readonly metricsTemporality?: AggregationTemporality | undefined
   readonly tracerExportInterval?: Duration.Input | undefined
   readonly shutdownTimeout?: Duration.Input | undefined
-}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> => {
+}): Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> => {
   const base = HttpClientRequest.get(options.baseUrl)
   const url = (path: string) => HttpClientRequest.appendUrl(base, path).url
   return Layer.mergeAll(
@@ -97,6 +102,12 @@ export const layer = (options: {
  * Creates a combined OTLP layer for logs, metrics, and traces from
  * OpenTelemetry configuration.
  *
+ * **Details**
+ *
+ * The layer provides the `OtlpExporter.Flusher` shared by all enabled signals.
+ * It is provided even when configuration disables every signal, in which case
+ * `flush` is a no-op.
+ *
  * @stability unstable
  * @category layers
  * @since 4.0.0
@@ -111,7 +122,7 @@ export const layerFromConfig = (options?: {
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
   readonly loggerExcludeLogSpans?: boolean | undefined
   readonly loggerMergeWithExisting?: boolean | undefined
-}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> =>
+}): Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> =>
   Layer.mergeAll(
     OtlpLogger.layerFromConfig({
       resource: options?.resource,
@@ -160,7 +171,10 @@ export const layerJson: (options: {
   readonly metricsTemporality?: AggregationTemporality | undefined
   readonly tracerExportInterval?: Duration.Input | undefined
   readonly shutdownTimeout?: Duration.Input | undefined
-}) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerJson))
+}) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient> = flow(
+  layer,
+  Layer.provide(OtlpSerialization.layerJson)
+)
 
 /**
  * Creates the combined OTLP logs, metrics, and traces layer using protobuf
@@ -192,4 +206,7 @@ export const layerProtobuf: (options: {
   readonly metricsTemporality?: AggregationTemporality | undefined
   readonly tracerExportInterval?: Duration.Input | undefined
   readonly shutdownTimeout?: Duration.Input | undefined
-}) => Layer.Layer<never, never, HttpClient.HttpClient> = flow(layer, Layer.provide(OtlpSerialization.layerProtobuf))
+}) => Layer.Layer<OtlpExporter.Flusher, never, HttpClient.HttpClient> = flow(
+  layer,
+  Layer.provide(OtlpSerialization.layerProtobuf)
+)

package/src/observability/OtlpProxy.ts

@@ -0,0 +1,314 @@
+/**
+ * Proxies OTLP HTTP exports from browsers through an application's own HTTP
+ * server to an OpenTelemetry Collector or vendor endpoint.
+ *
+ * A browser exporting OTLP directly would need the vendor credentials in its
+ * bundle and a cross-origin collector. `OtlpProxy` mounts `POST /v1/traces`,
+ * `/v1/logs`, and `/v1/metrics` on an `HttpRouter`, adds the configured
+ * headers on the server, and forwards the payload unchanged. The browser can
+ * then use `Otlp.layer({ baseUrl: "/otlp" })` against its own origin.
+ *
+ * **Details**
+ *
+ * - The upstream URL comes only from configuration. The request path and query
+ *   string never reach it.
+ * - Only `application/json` and `application/x-protobuf` bodies are accepted;
+ *   other content types get `415`. Payloads are not decoded or validated.
+ * - Only `content-type` and `content-encoding` are forwarded from the client.
+ *   Configured `headers` are applied last, so a client cannot override them.
+ * - Bodies are buffered up to `maxBodySize` and rejected with `413` beyond it.
+ * - Upstream requests send `accept-encoding: identity`, and the client's
+ *   `accept-encoding` is never forwarded.
+ * - The upstream status and body are returned with only the `content-type` and
+ *   `retry-after` headers, so client SDK back-off keeps working and upstream
+ *   cookies are dropped. Transport failures return `502` and timeouts `504`.
+ *   The proxy does not retry or batch.
+ *
+ * **Gotchas**
+ *
+ * - Anyone who can reach the routes can send telemetry with the configured
+ *   credentials. Compose authentication, CORS, and rate limiting around the
+ *   layer as the application requires.
+ * - The response body is returned as the `HttpClient` provides it, without a
+ *   `content-encoding` header. Setting `accept-encoding` in `headers` can
+ *   invalidate this, as can an upstream that compresses despite
+ *   `accept-encoding: identity`: clients that do not decode responses, such as
+ *   `NodeHttpClient.makeUndici`, then return compressed bytes.
+ * - Requests to the proxy routes are traced by the HTTP server like any other
+ *   route. To suppress those spans, provide `HttpMiddleware.TracerDisabledWhen`
+ *   with a predicate matching the routes, or use
+ *   `HttpMiddleware.layerTracerDisabledForUrls`, which matches exact URLs, so
+ *   list each route.
+ *
+ * @stability unstable
+ * @since 4.0.7
+ */
+import * as ByteSize from "../ByteSize.ts"
+import * as Duration from "../Duration.ts"
+import * as Effect from "../Effect.ts"
+import { constTrue } from "../Function.ts"
+import * as Headers from "../http/Headers.ts"
+import * as HttpClient from "../http/HttpClient.ts"
+import * as HttpClientRequest from "../http/HttpClientRequest.ts"
+import type * as HttpClientResponse from "../http/HttpClientResponse.ts"
+import * as HttpIncomingMessage from "../http/HttpIncomingMessage.ts"
+import * as HttpRouter from "../http/HttpRouter.ts"
+import * as HttpServerRequest from "../http/HttpServerRequest.ts"
+import * as HttpServerRespondable from "../http/HttpServerRespondable.ts"
+import * as HttpServerResponse from "../http/HttpServerResponse.ts"
+import * as Layer from "../Layer.ts"
+import * as OtlpEnv from "./internal/otlpEnv.ts"
+
+/**
+ * OTLP signal type served by the proxy.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.7
+ */
+export type Signal = "traces" | "logs" | "metrics"
+
+/**
+ * Creates a record of request handlers, one for each OTLP signal, that forward
+ * to the configured upstream.
+ *
+ * **When to use**
+ *
+ * Use to mount the proxy on routes or a router other than the ones `layer`
+ * registers, such as an `HttpApi` endpoint.
+ *
+ * **Details**
+ *
+ * Each signal is sent to `urls[signal]` when set, otherwise to
+ * `/v1/<signal>` below `baseUrl`. `maxBodySize` defaults to the
+ * `HttpIncomingMessage.MaxBodySize` reference, then 10 MiB. `timeout` defaults
+ * to 10 seconds.
+ *
+ * @see {@link layer} for mounting the handlers on an `HttpRouter`.
+ * @stability unstable
+ * @category constructors
+ * @since 4.0.7
+ */
+export const make = (options: {
+  readonly baseUrl: string
+  readonly urls?: Partial<Record<Signal, string>> | undefined
+  readonly headers?: Headers.Input | undefined
+  readonly maxBodySize?: ByteSize.Input | undefined
+  readonly timeout?: Duration.Input | undefined
+}): Effect.Effect<
+  Record<Signal, Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest>>,
+  never,
+  HttpClient.HttpClient
+> =>
+  Effect.gen(function*() {
+    const client = yield* HttpClient.HttpClient
+    const base = HttpClientRequest.post(options.baseUrl)
+    const handlers = {} as Record<Signal, Handler>
+    for (const signal of allSignals) {
+      handlers[signal] = makeHandler(client, {
+        ...options,
+        url: options.urls?.[signal] ?? HttpClientRequest.appendUrl(base, `/v1/${signal}`).url
+      })
+    }
+    return handlers
+  })
+
+/**
+ * Creates a layer that mounts the OTLP proxy routes on an `HttpRouter`.
+ *
+ * **Details**
+ *
+ * Registers `POST <prefix>/v1/<signal>` for each of `signals`, which defaults
+ * to traces, logs, and metrics. Without a `prefix` the routes are mounted at
+ * the router root.
+ *
+ * **Example** (Proxying browser telemetry to a vendor)
+ *
+ * ```ts import.meta.vitest
+ * import { Layer } from "effect"
+ * import { FetchHttpClient } from "effect/http"
+ * import { OtlpProxy } from "effect/observability"
+ *
+ * const OtlpProxyLayer = OtlpProxy.layer({
+ *   baseUrl: "https://otlp.vendor.example",
+ *   headers: { authorization: "Bearer server-side-key" },
+ *   prefix: "/otlp"
+ * }).pipe(Layer.provide(FetchHttpClient.layer))
+ *
+ * Layer.isLayer(OtlpProxyLayer) // => true
+ * ```
+ *
+ * @see {@link layerFromConfig} for reading the upstream from OpenTelemetry environment variables.
+ * @stability unstable
+ * @category layers
+ * @since 4.0.7
+ */
+export const layer = (options: {
+  readonly baseUrl: string
+  readonly urls?: Partial<Record<Signal, string>> | undefined
+  readonly headers?: Headers.Input | undefined
+  readonly maxBodySize?: ByteSize.Input | undefined
+  readonly timeout?: Duration.Input | undefined
+  readonly prefix?: string | undefined
+  readonly signals?: ReadonlyArray<Signal> | undefined
+}): Layer.Layer<never, never, HttpRouter.HttpRouter | HttpClient.HttpClient> =>
+  Layer.effectDiscard(Effect.gen(function*() {
+    const handlers = yield* make(options)
+    yield* addRoutes(
+      options.prefix,
+      (options.signals ?? allSignals).map((signal) => [signal, handlers[signal]] as const)
+    )
+  }))
+
+/**
+ * Creates a layer that mounts the OTLP proxy routes using the upstream from
+ * OpenTelemetry environment configuration.
+ *
+ * **Details**
+ *
+ * Each signal is sent to `OTEL_EXPORTER_OTLP_<SIGNAL>_ENDPOINT`, falling back
+ * to `/v1/<signal>` below `OTEL_EXPORTER_OTLP_ENDPOINT`, with headers from
+ * `OTEL_EXPORTER_OTLP_<SIGNAL>_HEADERS` or `OTEL_EXPORTER_OTLP_HEADERS`. The
+ * `headers` option replaces the configured headers. Signals without an
+ * endpoint get no route.
+ *
+ * @see {@link layer} for configuring the upstream directly.
+ * @stability unstable
+ * @category layers
+ * @since 4.0.7
+ */
+export const layerFromConfig = (options?: {
+  readonly headers?: Headers.Input | undefined
+  readonly maxBodySize?: ByteSize.Input | undefined
+  readonly timeout?: Duration.Input | undefined
+  readonly prefix?: string | undefined
+  readonly signals?: ReadonlyArray<Signal> | undefined
+}): Layer.Layer<never, never, HttpRouter.HttpRouter | HttpClient.HttpClient> =>
+  Layer.effectDiscard(
+    Effect.gen(function*() {
+      const client = yield* HttpClient.HttpClient
+      const routes: Array<readonly [Signal, Handler]> = []
+      for (const signal of options?.signals ?? allSignals) {
+        const envSignal = signal.toUpperCase() as OtlpEnv.Signal
+        const url = yield* OtlpEnv.endpoint(envSignal)
+        if (url === undefined) continue
+        routes.push([
+          signal,
+          makeHandler(client, {
+            ...options,
+            url: url.toString(),
+            headers: options?.headers ?? (yield* OtlpEnv.headers(envSignal))
+          })
+        ])
+      }
+      yield* addRoutes(options?.prefix, routes)
+    }).pipe(Effect.orDie)
+  )
+
+// internal
+
+const allSignals: ReadonlyArray<Signal> = ["traces", "logs", "metrics"]
+
+const contentTypes = new Set(["application/json", "application/x-protobuf"])
+
+const defaultMaxBodySize = ByteSize.mebibytes(10)
+
+type Handler = Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest>
+
+const addRoutes = Effect.fnUntraced(function*(
+  prefix: string | undefined,
+  routes: Iterable<readonly [signal: Signal, handler: Handler]>
+) {
+  const router = yield* HttpRouter.HttpRouter
+  const target = prefix === undefined ? router : router.prefixed(prefix)
+  for (const [signal, handler] of routes) {
+    yield* target.add("POST", `/v1/${signal}`, handler)
+  }
+})
+
+const makeHandler = (client: HttpClient.HttpClient, options: {
+  readonly url: string
+  readonly headers?: Headers.Input | undefined
+  readonly maxBodySize?: ByteSize.Input | undefined
+  readonly timeout?: Duration.Input | undefined
+}): Handler => {
+  // Skips the outbound span and trace headers in one step.
+  const upstream = client.pipe(
+    HttpClient.transformResponse(Effect.provideService(HttpClient.TracerDisabledWhen, constTrue))
+  )
+  const headers = Headers.fromInput(options.headers)
+  const maxBodySize = options.maxBodySize === undefined ? undefined : ByteSize.fromInputUnsafe(options.maxBodySize)
+  const timeout = options.timeout ?? Duration.seconds(10)
+
+  return Effect.gen(function*() {
+    const request = yield* HttpServerRequest.HttpServerRequest
+    const contentType = request.headers["content-type"]
+    if (!isSupportedContentType(contentType)) {
+      return unsupportedMediaType
+    }
+    const limit = maxBodySize ?? (yield* HttpIncomingMessage.MaxBodySize) ?? defaultMaxBodySize
+    // Node's reader only counts bytes as they arrive, and would send
+    // 100 Continue first, so reject an over-limit declared length up front.
+    const contentLength = parseContentLength(request.headers["content-length"])
+    if (contentLength !== undefined && contentLength > Number(limit)) {
+      return contentTooLarge
+    }
+    const body = yield* request.arrayBuffer.pipe(
+      Effect.provideService(HttpIncomingMessage.MaxBodySize, limit),
+      Effect.catch(HttpServerRespondable.toResponse)
+    )
+    if (HttpServerResponse.isHttpServerResponse(body)) {
+      return body
+    }
+
+    let outbound = HttpClientRequest.bodyUint8Array(
+      HttpClientRequest.post(options.url),
+      new Uint8Array(body),
+      contentType
+    )
+    const contentEncoding = request.headers["content-encoding"]
+    if (contentEncoding !== undefined) {
+      outbound = HttpClientRequest.setHeader(outbound, "content-encoding", contentEncoding)
+    }
+    // The response is returned without content-encoding, so request it
+    // uncompressed. Configured headers can still override this.
+    outbound = HttpClientRequest.setHeader(outbound, "accept-encoding", "identity")
+    return yield* upstream.execute(HttpClientRequest.setHeaders(outbound, headers)).pipe(
+      Effect.flatMap((response) => Effect.map(response.arrayBuffer, (body) => toServerResponse(response, body))),
+      Effect.timeout(timeout),
+      Effect.catchTags({
+        TimeoutError: () => Effect.succeed(gatewayTimeout),
+        HttpClientError: () => Effect.succeed(badGateway)
+      })
+    )
+  })
+}
+
+const unsupportedMediaType = HttpServerResponse.empty({ status: 415 })
+const contentTooLarge = HttpServerResponse.empty({ status: 413 })
+const badGateway = HttpServerResponse.empty({ status: 502 })
+const gatewayTimeout = HttpServerResponse.empty({ status: 504 })
+
+const isSupportedContentType = (contentType: string | undefined): contentType is string =>
+  contentType !== undefined &&
+  (contentTypes.has(contentType) || contentTypes.has(contentType.split(";")[0].trim().toLowerCase()))
+
+const parseContentLength = (contentLength: string | undefined): number | undefined =>
+  contentLength !== undefined && /^\d+$/.test(contentLength) ? Number(contentLength) : undefined
+
+const toServerResponse = (
+  response: HttpClientResponse.HttpClientResponse,
+  body: ArrayBuffer
+): HttpServerResponse.HttpServerResponse => {
+  const headers: Record<string, string> = {}
+  if (response.headers["retry-after"] !== undefined) {
+    headers["retry-after"] = response.headers["retry-after"]
+  }
+  return body.byteLength === 0
+    ? HttpServerResponse.empty({ status: response.status, headers })
+    : HttpServerResponse.uint8Array(new Uint8Array(body), {
+      status: response.status,
+      headers,
+      contentType: response.headers["content-type"]
+    })
+}

package/src/observability/OtlpResource.ts

@@ -79,6 +79,13 @@ export const make = (options: {
  * precedence over matching attributes in `OTEL_RESOURCE_ATTRIBUTES`. Missing
  * required configuration is converted to a defect.
  *
+ * Keys and values in `OTEL_RESOURCE_ATTRIBUTES` are trimmed, then
+ * percent-decoded. Entries with an empty value are kept as `""`; entries
+ * without `=` or with an empty key are skipped. When a key is repeated as
+ * written, the last entry wins and the earlier ones are not decoded. Invalid
+ * percent-encoding in the remaining entries is a `ConfigError` and is
+ * converted to a defect.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
@@ -97,7 +104,8 @@ export const fromConfig: (
   const env = yield* Config.Record(
     Schema.StringFromUriComponent,
     Schema.StringFromUriComponent,
-    "OTEL_RESOURCE_ATTRIBUTES"
+    "OTEL_RESOURCE_ATTRIBUTES",
+    { trim: true, keepEmptyValues: true }
   ).pipe(Config.withDefault(undefined))
 
   const serviceName = options?.serviceName

package/src/observability/OtlpTracer.ts

@@ -281,6 +281,7 @@ class SpanImpl implements Tracer.Span {
   }
 
   end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void {
+    if (this.status._tag === "Ended") return
     this.status = {
       _tag: "Ended",
       startTime: this.status.startTime,
@@ -291,14 +292,17 @@ class SpanImpl implements Tracer.Span {
   }
 
   attribute(key: string, value: unknown): void {
+    if (this.status._tag === "Ended") return
     this.attributes.set(key, value)
   }
 
   event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void {
+    if (this.status._tag === "Ended") return
     this.events.push([name, startTime, attributes])
   }
 
   addLinks(links: ReadonlyArray<Tracer.SpanLink>): void {
+    if (this.status._tag === "Ended") return
     // oxlint-disable-next-line no-restricted-syntax
     this.links.push(...links)
   }

package/src/observability/index.ts

@@ -29,6 +29,12 @@ export * as OtlpLogger from "./OtlpLogger.ts"
  */
 export * as OtlpMetrics from "./OtlpMetrics.ts"
 
+/**
+ * @stability unstable
+ * @since 4.0.7
+ */
+export * as OtlpProxy from "./OtlpProxy.ts"
+
 /**
  * @stability unstable
  * @since 4.0.0