effect 4.0.4 → 4.0.5

package/src/http/internal/decompression.ts

@@ -0,0 +1,226 @@
+import * as ByteSize from "../../ByteSize.ts"
+import * as Effect from "../../Effect.ts"
+import * as Inspectable from "../../Inspectable.ts"
+import type * as Option from "../../Option.ts"
+import type { ReadonlyRecord } from "../../Record.ts"
+import type * as Schema from "../../Schema.ts"
+import type * as Socket from "../../socket/Socket.ts"
+import * as Stream from "../../Stream.ts"
+import * as Headers from "../Headers.ts"
+import * as HttpIncomingMessage from "../HttpIncomingMessage.ts"
+import type { HttpMethod } from "../HttpMethod.ts"
+import { HttpServerError, RequestParseError } from "../HttpServerError.ts"
+import * as HttpServerRequest from "../HttpServerRequest.ts"
+import * as Multipart from "../Multipart.ts"
+import * as UrlParams from "../UrlParams.ts"
+
+/**
+ * @internal
+ */
+export type Coding = "gzip" | "deflate"
+
+const defaultMaxDecompressedSize = ByteSize.mebibytes(10)
+
+/**
+ * Parses a `Content-Encoding` header into the codings to undo, in the order
+ * they were applied. `identity` members are dropped. Returns `undefined` if
+ * any member is unsupported.
+ *
+ * @internal
+ */
+export const parseContentEncoding = (header: string): ReadonlyArray<Coding> | undefined => {
+  const codings: Array<Coding> = []
+  for (const member of header.split(",")) {
+    const coding = member.trim().toLowerCase()
+    if (coding === "" || coding === "identity") continue
+    if (coding !== "gzip" && coding !== "deflate") return undefined
+    codings.push(coding)
+  }
+  return codings
+}
+
+/**
+ * Wraps a request so that its body accessors yield the decompressed body.
+ * Decompression happens lazily, when a body accessor is read.
+ *
+ * @internal
+ */
+export class DecompressedRequest extends Inspectable.Class implements HttpServerRequest.HttpServerRequest {
+  readonly [HttpServerRequest.TypeId]: typeof HttpServerRequest.TypeId
+  readonly [HttpIncomingMessage.TypeId]: typeof HttpIncomingMessage.TypeId
+  readonly inner: HttpServerRequest.HttpServerRequest
+  readonly codings: ReadonlyArray<Coding>
+  readonly maxDecompressedSize: ByteSize.ByteSize | undefined
+  readonly headers: Headers.Headers
+
+  constructor(
+    inner: HttpServerRequest.HttpServerRequest,
+    codings: ReadonlyArray<Coding>,
+    maxDecompressedSize: ByteSize.ByteSize | undefined
+  ) {
+    super()
+    this[HttpServerRequest.TypeId] = HttpServerRequest.TypeId
+    this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId
+    this.inner = inner
+    this.codings = codings
+    this.maxDecompressedSize = maxDecompressedSize
+    this.headers = Headers.removeMany(inner.headers, ["content-encoding", "content-length"])
+  }
+
+  toJSON(): unknown {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    })
+  }
+
+  modify(
+    options: {
+      readonly url?: string
+      readonly headers?: Headers.Headers
+      readonly remoteAddress?: Option.Option<string>
+    }
+  ): HttpServerRequest.HttpServerRequest {
+    return new DecompressedRequest(this.inner.modify(options), this.codings, this.maxDecompressedSize)
+  }
+
+  get source(): object {
+    return this.inner.source
+  }
+
+  get url(): string {
+    return this.inner.url
+  }
+
+  get originalUrl(): string {
+    return this.inner.originalUrl
+  }
+
+  get method(): HttpMethod {
+    return this.inner.method
+  }
+
+  get cookies(): ReadonlyRecord<string, string> {
+    return this.inner.cookies
+  }
+
+  get remoteAddress(): Option.Option<string> {
+    return this.inner.remoteAddress
+  }
+
+  get upgrade(): Effect.Effect<Socket.Socket, HttpServerError> {
+    return this.inner.upgrade
+  }
+
+  // Platform accessors such as `NodeHttpServerRequest.toServerResponse` read
+  // the response handle from the request.
+  get response(): unknown {
+    return (this.inner as any).response
+  }
+
+  get stream(): Stream.Stream<Uint8Array, HttpServerError> {
+    return Stream.unwrap(Effect.withFiber((fiber) => {
+      const limit = this.maxDecompressedSize ?? fiber.getRef(HttpIncomingMessage.MaxBodySize) ??
+        defaultMaxDecompressedSize
+      return Effect.succeed(Stream.fromReadableStream({
+        evaluate: () => {
+          let body = Stream.toReadableStreamWith(this.inner.stream, fiber.context)
+          for (let i = this.codings.length - 1; i >= 0; i--) {
+            body = body.pipeThrough(
+              new DecompressionStream(this.codings[i]) as unknown as ReadableWritablePair<Uint8Array, Uint8Array>
+            )
+          }
+          let size = 0
+          return body.pipeThrough(
+            new TransformStream<Uint8Array, Uint8Array>({
+              transform: (chunk, controller) => {
+                size += chunk.byteLength
+                if (size > limit) {
+                  controller.error(
+                    this.parseError(undefined, `Decompressed request body exceeds ${limit} bytes`, "BodyTooLarge")
+                  )
+                } else {
+                  controller.enqueue(chunk)
+                }
+              }
+            })
+          )
+        },
+        onError: (cause) => cause instanceof HttpServerError ? cause : this.parseError(cause)
+      }))
+    }))
+  }
+
+  private bytesEffect: Effect.Effect<Uint8Array, HttpServerError> | undefined
+  private get bytes(): Effect.Effect<Uint8Array, HttpServerError> {
+    return this.bytesEffect ??= Effect.runSync(Effect.cached(Stream.mkUint8Array(this.stream)))
+  }
+
+  get text(): Effect.Effect<string, HttpServerError> {
+    return Effect.map(this.bytes, (bytes) => textDecoder.decode(bytes))
+  }
+
+  get json(): Effect.Effect<Schema.Json, HttpServerError> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => text === "" ? null : JSON.parse(text) as Schema.Json,
+        catch: (cause) => this.parseError(cause)
+      }))
+  }
+
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpServerError> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(text)),
+        catch: (cause) => this.parseError(cause)
+      }))
+  }
+
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpServerError> {
+    return Effect.map(
+      this.bytes,
+      (bytes) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
+    )
+  }
+
+  get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
+    return Stream.pipeThroughChannel(
+      Stream.mapError(
+        this.stream,
+        (cause) => Multipart.MultipartError.fromReason(multipartReasons.get(cause) ?? "InternalError", cause)
+      ),
+      Multipart.makeChannel(this.headers)
+    )
+  }
+
+  private multipartEffect: HttpServerRequest.HttpServerRequest["multipart"] | undefined
+  get multipart(): HttpServerRequest.HttpServerRequest["multipart"] {
+    return this.multipartEffect ??= Effect.runSync(Effect.cached(Multipart.toPersisted(this.multipartStream)))
+  }
+
+  private parseError(
+    cause: unknown,
+    description?: string,
+    multipartReason: MultipartReason = "Parse"
+  ): HttpServerError {
+    const error = new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        ...(description === undefined ? undefined : { description }),
+        ...(cause === undefined ? undefined : { cause })
+      })
+    })
+    multipartReasons.set(error, multipartReason)
+    return error
+  }
+}
+
+const textDecoder = new TextDecoder()
+
+type MultipartReason = "Parse" | "BodyTooLarge"
+
+// Failures caused by the client's data, keyed to the multipart reason they map
+// to. Transport errors from the inner request are absent and map to
+// `InternalError`.
+const multipartReasons = new WeakMap<HttpServerError, MultipartReason>()

package/src/http/internal/tracing.ts

@@ -1,5 +1,6 @@
 import type * as Tracer from "../../Tracer.ts"
 import * as Headers from "../Headers.ts"
+import * as UrlParams from "../UrlParams.ts"
 
 const defaultPorts: Record<string, number> = {
   "http:": 80,
@@ -9,16 +10,17 @@ const defaultPorts: Record<string, number> = {
 }
 
 /**
- * Records the `url.*` and `server.*` attributes for a request URL.
+ * Records `url.*` and `server.*` attributes with URL redaction.
  *
  * @internal
  */
 export const addUrlAttributes = (
   span: Tracer.Span,
-  url: URL
+  url: URL,
+  redactedNames: ReadonlyArray<string | RegExp>
 ): void => {
-  const query = url.search.slice(1)
-  span.attribute("url.full", url.toString())
+  const query = UrlParams.redactUrl(url.search, redactedNames).slice(1)
+  span.attribute("url.full", UrlParams.redactUrl(url.href, redactedNames))
   span.attribute("url.path", url.pathname)
   if (query !== "") {
     span.attribute("url.query", query)
@@ -34,6 +36,21 @@ export const addUrlAttributes = (
   }
 }
 
+/**
+ * Adds the names of `Redacted` parameters to the redacted names.
+ *
+ * @internal
+ */
+export const redactedNames = (
+  urlParams: UrlParams.UrlParams,
+  redactedNames: ReadonlyArray<string | RegExp>
+): ReadonlyArray<string | RegExp> => {
+  const keys = urlParams.params.filter(([, value]) => typeof value !== "string").map(([key]) => key)
+  return keys.length === 0
+    ? redactedNames
+    : [...redactedNames, ...new URLSearchParams(keys.map((key) => [key, ""])).keys()]
+}
+
 /** @internal */
 export const addHeaderAttributes = (
   span: Tracer.Span,

package/src/http/internal/urlParams.ts

@@ -0,0 +1,5 @@
+import * as Redacted from "../../Redacted.ts"
+
+/** @internal */
+export const unwrap = (value: string | Redacted.Redacted): string =>
+  typeof value === "string" ? value : Redacted.value(value)

package/src/http-api/HttpApiClient.ts

@@ -23,6 +23,7 @@ import * as HttpClientError from "../http/HttpClientError.ts"
 import * as HttpClientRequest from "../http/HttpClientRequest.ts"
 import type * as HttpClientResponse from "../http/HttpClientResponse.ts"
 import * as HttpMethod from "../http/HttpMethod.ts"
+import * as internalUrlParams from "../http/internal/urlParams.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import * as InternalRecord from "../internal/record.ts"
 import * as Predicate from "../Predicate.ts"
@@ -746,7 +747,7 @@ export const urlBuilder = <Api extends HttpApi.Constraint>(api: Api, options?: {
         )
         for (const [key, value] of urlParams.params) {
           if (value !== undefined) {
-            url.searchParams.append(key, value)
+            url.searchParams.append(key, internalUrlParams.unwrap(value))
           }
         }
         return url.toString()

package/src/internal/core.ts

@@ -321,6 +321,26 @@ export const causeCombine: {
   }
 )
 
+/**
+ * Appends the interrupts from `interrupts` that `self` does not contain yet.
+ * Unlike `causeCombine`, it never calls hash or equality methods, which can be
+ * user-defined, random, or throwing.
+ *
+ * @internal
+ */
+export const causeAddInterrupts = <E>(self: Cause.Cause<E>, interrupts: Cause.Cause<never>): Cause.Cause<E> => {
+  const reasons: Array<Cause.Reason<E>> = self.reasons.slice()
+  for (const reason of interrupts.reasons) {
+    if (
+      isInterruptReason(reason) &&
+      !reasons.some((r) => isInterruptReason(r) && r.fiberId === reason.fiberId && r.annotations === reason.annotations)
+    ) {
+      reasons.push(reason)
+    }
+  }
+  return reasons.length === self.reasons.length ? self : new CauseImpl(reasons)
+}
+
 /** @internal */
 export const causeEmpty: Cause.Cause<never> = new CauseImpl([])
 
@@ -600,7 +620,7 @@ export const exitFailCause: <E>(cause: Cause.Cause<E>) => Exit.Exit<never, E> =
       if (skippedHandler) {
         cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"))
       }
-      cause = causeCombine(cause, interruptedCause)
+      cause = causeAddInterrupts(cause, interruptedCause)
       annotated = true
     }
     return cont

package/src/internal/effect.ts

@@ -49,6 +49,7 @@ import { internalCall } from "../Utils.ts"
 import type { Primitive } from "./core.ts"
 import {
   args,
+  causeAddInterrupts,
   causeAnnotate,
   causeCombine,
   causeEmpty,
@@ -130,9 +131,9 @@ export class Interrupt extends ReasonBase<"Interrupt"> implements Cause.Interrup
     )
   }
   [Hash.symbol](): number {
-    return Hash.combine(Hash.string(`${this._tag}:${this.fiberId}`))(
-      Hash.random(this.annotations)
-    )
+    // Equality compares annotations by reference, so leave them out instead of
+    // hashing them randomly.
+    return Hash.string(`${this._tag}:${this.fiberId}`)
   }
 }
 
@@ -566,7 +567,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
       cause = causeAnnotate(cause, annotations)
     }
     this._interruptedCause = this._interruptedCause
-      ? causeCombine(this._interruptedCause, cause)
+      ? causeAddInterrupts(this._interruptedCause, cause)
       : cause
     if (this.interruptible) {
       if (this._running) {

package/src/internal/graphql.ts

@@ -12,7 +12,7 @@ import {
   type Reason,
   ResponseError
 } from "../graphql/GraphQLClientError.ts"
-import type { ExecutionResult, GraphQLRequest } from "../graphql/GraphQLProtocol.ts"
+import type { ExecutionResult, GraphQLProtocol, GraphQLRequest } from "../graphql/GraphQLProtocol.ts"
 import * as Schema from "../Schema.ts"
 
 /**
@@ -153,6 +153,29 @@ export const renderSlices = (
  */
 export const ForcePost = Context.Reference<boolean>("effect/graphql/ForcePost", { defaultValue: () => false })
 
+/**
+ * The URL a resolver batch was grouped by, and the protocol `url` that
+ * resolved it, so that transport sends the batch there without resolving it
+ * again.
+ *
+ * @internal
+ */
+export type ResolvedUrl = {
+  readonly resolve: GraphQLProtocol["Service"]["url"]
+  readonly url: string
+} | undefined
+
+/**
+ * Carries a {@link ResolvedUrl} from a resolver batch to the transport. The
+ * client clears it while middleware run, so calls they make resolve their
+ * own URL.
+ *
+ * @internal
+ */
+export const ResolvedUrl = Context.Reference<ResolvedUrl>("effect/graphql/ResolvedUrl", {
+  defaultValue: () => undefined
+})
+
 /**
  * JSON with object keys sorted, so equal JSON values give equal strings.
  *
@@ -219,15 +242,15 @@ export const makeCodec = <Op extends GraphQL.Any>(operation: Op) => {
 }
 
 /**
- * Each real client method's runner for batches: its middleware and protocol,
- * sending as POST. Mock and custom methods have none.
+ * Client batch runners (middleware and protocol, using POST) and URLs for
+ * resolver grouping. Mock and custom methods are not registered.
  *
  * @internal
  */
-export const rawExecutors = new WeakMap<
-  object,
-  (request: GraphQLRequest) => Effect.Effect<ExecutionResult, unknown, unknown>
->()
+export const rawExecutors = new WeakMap<object, {
+  readonly execute: (request: GraphQLRequest) => Effect.Effect<ExecutionResult, unknown, unknown>
+  readonly url: GraphQLProtocol["Service"]["url"]
+}>()
 
 /**
  * Splits a batched response, removing prefixes from root keys and error paths.

package/src/internal/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.0.4"
+export const version = "4.0.5"

package/src/observability/Otlp.ts

@@ -42,6 +42,11 @@ export const layer = (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
+  /**
+   * Request compression. Defaults to "none". Gzip uses
+   * HttpClientRequest's default minimum body size of 1KB.
+   */
+  readonly compression?: "gzip" | "none" | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
   readonly loggerExportInterval?: Duration.Input | undefined
@@ -59,6 +64,7 @@ export const layer = (options: {
       url: url("/v1/logs"),
       resource: options.resource,
       headers: options.headers,
+      compression: options.compression,
       exportInterval: options.loggerExportInterval,
       maxBatchSize: options.maxBatchSize,
       shutdownTimeout: options.shutdownTimeout,
@@ -69,6 +75,7 @@ export const layer = (options: {
       url: url("/v1/metrics"),
       resource: options.resource,
       headers: options.headers,
+      compression: options.compression,
       exportInterval: options.metricsExportInterval,
       shutdownTimeout: options.shutdownTimeout,
       temporality: options.metricsTemporality
@@ -77,6 +84,7 @@ export const layer = (options: {
       url: url("/v1/traces"),
       resource: options.resource,
       headers: options.headers,
+      compression: options.compression,
       exportInterval: options.tracerExportInterval,
       maxBatchSize: options.maxBatchSize,
       context: options.tracerContext,
@@ -138,6 +146,11 @@ export const layerJson: (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
+  /**
+   * Request compression. Defaults to "none". Gzip uses
+   * HttpClientRequest's default minimum body size of 1KB.
+   */
+  readonly compression?: "gzip" | "none" | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
   readonly loggerExportInterval?: Duration.Input | undefined
@@ -165,6 +178,11 @@ export const layerProtobuf: (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
+  /**
+   * Request compression. Defaults to "none". Gzip uses
+   * HttpClientRequest's default minimum body size of 1KB.
+   */
+  readonly compression?: "gzip" | "none" | undefined
   readonly maxBatchSize?: number | undefined
   readonly tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
   readonly loggerExportInterval?: Duration.Input | undefined

package/src/observability/OtlpExporter.ts

@@ -161,6 +161,12 @@ export const layerFlusher: Layer.Layer<Flusher> = Layer.sync(Flusher, () => {
  * after unhandled failures, and flushes during scope finalization up to
  * `shutdownTimeout`.
  *
+ * Optional gzip compression uses `HttpClientRequest.compressBody` before the
+ * retry loop, so retries reuse the compressed bytes. Bodies smaller than 1KB
+ * remain uncompressed. Compression requires runtime `CompressionStream` support;
+ * compression failures follow the same temporary-disable behavior as transport
+ * failures and do not fail flushing or shutdown.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
@@ -169,6 +175,8 @@ export const make: (
   options: {
     readonly url: string
     readonly headers: Headers.Input | undefined
+    /** Gzip uses the default 1KB minimum body size; smaller batches remain uncompressed. */
+    readonly compression?: "gzip" | "none" | undefined
     readonly label: string
     readonly exportInterval: Duration.Input
     readonly maxBatchSize: number | "disabled"
@@ -218,9 +226,12 @@ export const make: (
     const items = buffer
     buffer = []
     const [body, onSuccess] = options.body(items)
-    return client.execute(
-      HttpClientRequest.setBody(request, body)
-    ).pipe(
+    const batchRequest = HttpClientRequest.setBody(request, body)
+    // Compress before client.execute so transient retries reuse the encoded bytes.
+    const response = options.compression === "gzip"
+      ? HttpClientRequest.compressBody(batchRequest, "gzip").pipe(Effect.flatMap(client.execute))
+      : client.execute(batchRequest)
+    return response.pipe(
       Effect.andThen(onSuccess),
       Effect.asVoid,
       Effect.withTracerEnabled(false)

package/src/observability/OtlpLogger.ts

@@ -52,6 +52,11 @@ export const make: (
       readonly attributes?: Record<string, unknown>
     } | undefined
     readonly headers?: Headers.Input | undefined
+    /**
+     * Request compression. Defaults to "none". Gzip uses
+     * HttpClientRequest's default minimum body size of 1KB.
+     */
+    readonly compression?: "gzip" | "none" | undefined
     readonly exportInterval?: Duration.Input | undefined
     readonly maxBatchSize?: number | undefined
     readonly shutdownTimeout?: Duration.Input | undefined
@@ -73,6 +78,7 @@ export const make: (
     label: "OtlpLogger",
     url: options.url,
     headers: options.headers,
+    compression: options.compression,
     maxBatchSize: options.maxBatchSize ?? 1000,
     exportInterval: options.exportInterval ?? Duration.seconds(1),
     body: (data) => [
@@ -118,6 +124,11 @@ export const layer = (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
+  /**
+   * Request compression. Defaults to "none". Gzip uses
+   * HttpClientRequest's default minimum body size of 1KB.
+   */
+  readonly compression?: "gzip" | "none" | undefined
   readonly exportInterval?: Duration.Input | undefined
   readonly maxBatchSize?: number | undefined
   readonly shutdownTimeout?: Duration.Input | undefined
@@ -131,6 +142,13 @@ export const layer = (options: {
 /**
  * Creates an OTLP logs layer from OpenTelemetry configuration.
  *
+ * **Details**
+ *
+ * Compression accepts "gzip" or "none".
+ * `OTEL_EXPORTER_OTLP_LOGS_COMPRESSION` takes precedence over
+ * `OTEL_EXPORTER_OTLP_COMPRESSION`, defaulting to "none". Gzip uses
+ * HttpClientRequest's default minimum body size of 1KB.
+ *
  * @stability unstable
  * @category layers
  * @since 4.0.0
@@ -156,7 +174,17 @@ export const layerFromConfig = (options?: {
       return Exporter.layerFlusher
     }
 
-    const { baseTimeout, logsTimeout, exportTimeout, scheduleDelay, maxBatchSize } = yield* Config.all({
+    const {
+      baseCompression,
+      compression,
+      baseTimeout,
+      logsTimeout,
+      exportTimeout,
+      scheduleDelay,
+      maxBatchSize
+    } = yield* Config.all({
+      baseCompression: Config.option(Config.Literals(["gzip", "none"], "OTEL_EXPORTER_OTLP_COMPRESSION")),
+      compression: Config.option(Config.Literals(["gzip", "none"], "OTEL_EXPORTER_OTLP_LOGS_COMPRESSION")),
       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")),
@@ -173,6 +201,7 @@ export const layerFromConfig = (options?: {
       url: endpoint.toString(),
       resource: options?.resource,
       headers: options?.headers ?? (yield* OtlpEnv.headers("LOGS")),
+      compression: Option.getOrElse(Option.firstSomeOf([compression, baseCompression]), () => "none" as const),
       exportInterval: Option.getOrUndefined(exportInterval),
       maxBatchSize: Option.getOrUndefined(maxBatchSize),
       shutdownTimeout: Option.getOrUndefined(shutdownTimeout),
@@ -232,7 +261,7 @@ const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   }
 
   if (options.fiber.cache.span) {
-    logRecord.traceId = options.fiber.cache.span.traceId
+    logRecord.traceId = options.fiber.cache.span.traceId.padStart(32, "0")
     logRecord.spanId = options.fiber.cache.span.spanId
   }
 

package/src/observability/OtlpMetrics.ts

@@ -89,6 +89,11 @@ export const make: (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
+  /**
+   * Request compression. Defaults to "none". Gzip uses
+   * HttpClientRequest's default minimum body size of 1KB.
+   */
+  readonly compression?: "gzip" | "none" | undefined
   readonly exportInterval?: Duration.Input | undefined
   readonly shutdownTimeout?: Duration.Input | undefined
   readonly temporality?: AggregationTemporality | undefined
@@ -387,6 +392,7 @@ export const make: (options: {
     label: "OtlpMetrics",
     url: options.url,
     headers: options.headers,
+    compression: options.compression,
     maxBatchSize: "disabled",
     exportEmpty: true,
     exportInterval: options.exportInterval ?? Duration.seconds(10),
@@ -410,6 +416,11 @@ export const layer = (options: {
     readonly attributes?: Record<string, unknown>
   } | undefined
   readonly headers?: Headers.Input | undefined
+  /**
+   * Request compression. Defaults to "none". Gzip uses
+   * HttpClientRequest's default minimum body size of 1KB.
+   */
+  readonly compression?: "gzip" | "none" | undefined
   readonly exportInterval?: Duration.Input | undefined
   readonly shutdownTimeout?: Duration.Input | undefined
   readonly temporality?: AggregationTemporality | undefined
@@ -419,6 +430,13 @@ export const layer = (options: {
 /**
  * Creates an OTLP metrics layer from OpenTelemetry configuration.
  *
+ * **Details**
+ *
+ * Compression accepts "gzip" or "none".
+ * `OTEL_EXPORTER_OTLP_METRICS_COMPRESSION` takes precedence over
+ * `OTEL_EXPORTER_OTLP_COMPRESSION`, defaulting to "none". Gzip uses
+ * HttpClientRequest's default minimum body size of 1KB.
+ *
  * @stability unstable
  * @category layers
  * @since 4.0.0
@@ -441,7 +459,17 @@ export const layerFromConfig = (options?: {
       return Exporter.layerFlusher
     }
 
-    const { baseTimeout, metricsTimeout, exportTimeout, exportInterval, temporalityPreference } = yield* Config.all({
+    const {
+      baseCompression,
+      compression,
+      baseTimeout,
+      metricsTimeout,
+      exportTimeout,
+      exportInterval,
+      temporalityPreference
+    } = yield* Config.all({
+      baseCompression: Config.option(Config.Literals(["gzip", "none"], "OTEL_EXPORTER_OTLP_COMPRESSION")),
+      compression: Config.option(Config.Literals(["gzip", "none"], "OTEL_EXPORTER_OTLP_METRICS_COMPRESSION")),
       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")),
@@ -463,6 +491,7 @@ export const layerFromConfig = (options?: {
       url: endpoint.toString(),
       resource: options?.resource,
       headers: options?.headers ?? (yield* OtlpEnv.headers("METRICS")),
+      compression: Option.getOrElse(Option.firstSomeOf([compression, baseCompression]), () => "none" as const),
       exportInterval: Option.getOrUndefined(exportInterval),
       shutdownTimeout: Option.getOrUndefined(shutdownTimeout),
       temporality: Option.getOrUndefined(temporalityPreference)