Add HttpClient tracer header filter

.changeset/add-http-client-tracer-header-filter.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+Add a configurable filter for HTTP client request and response header span attributes.

packages/effect/src/unstable/http/HttpClient.ts

@@ -687,8 +687,10 @@ export const make = (
               span.attribute("url.query", query)
             }
             const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
+            const headerFilter = fiber.getRef(TracerHeaderFilter)
             const redactedHeaders = Headers.redact(request.headers, redactedHeaderNames)
             for (const name in redactedHeaders) {
+              if (!headerFilter(name, "request")) continue
               span.attribute(`http.request.header.${name}`, String(redactedHeaders[name]))
             }
             request = fiber.getRef(TracerPropagationEnabled)
@@ -702,6 +704,7 @@ export const make = (
                     span.attribute("http.response.status_code", response.status)
                     const redactedHeaders = Headers.redact(response.headers, redactedHeaderNames)
                     for (const name in redactedHeaders) {
+                      if (!headerFilter(name, "response")) continue
                       span.attribute(`http.response.header.${name}`, String(redactedHeaders[name]))
                     }
 
@@ -1508,6 +1511,18 @@ export const TracerDisabledWhen = Context.Reference<
   defaultValue: () => constFalse
 })
 
+/**
+ * Context reference for filtering request and response headers added to client spans.
+ *
+ * @category references
+ * @since 4.0.0
+ */
+export const TracerHeaderFilter = Context.Reference<
+  (headerName: string, phase: "request" | "response") => boolean
+>("effect/http/HttpClient/TracerHeaderFilter", {
+  defaultValue: () => constTrue
+})
+
 /**
  * Context reference that controls whether outgoing client spans are propagated to request headers.
  *

packages/effect/test/unstable/http/HttpClient.test.ts

@@ -2,6 +2,7 @@ import { assert, describe, it } from "@effect/vitest"
 import { strictEqual } from "@effect/vitest/utils"
 import { Clock, Duration, Effect, Fiber, Layer, Ref, Stream } from "effect"
 import { TestClock } from "effect/testing"
+import * as Tracer from "effect/Tracer"
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { RateLimiter } from "effect/unstable/persistence"
 
@@ -37,6 +38,109 @@ const makeRedirectClient = Effect.fnUntraced(function*(status: number, location:
 const RateLimiterTestLayer = RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory))
 
 describe("HttpClient", () => {
+  describe("tracer", () => {
+    it.effect("includes request and response headers by default", () =>
+      Effect.gen(function*() {
+        let clientSpan: Tracer.NativeSpan | undefined
+        const tracer = Tracer.make({
+          span(options) {
+            clientSpan = new Tracer.NativeSpan(options)
+            return clientSpan
+          }
+        })
+        const client = HttpClient.make((request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              new Response(null, {
+                headers: { "x-response-default": "response" }
+              })
+            )
+          )
+        )
+
+        yield* client.get("http://test/", {
+          headers: { "x-request-default": "request" }
+        }).pipe(Effect.provideService(Tracer.Tracer, tracer))
+
+        assert(clientSpan !== undefined)
+        assert.strictEqual(clientSpan.attributes.get("http.request.header.x-request-default"), "request")
+        assert.strictEqual(clientSpan.attributes.get("http.response.header.x-response-default"), "response")
+      }))
+
+    it.effect("filters request and response header span attributes", () =>
+      Effect.gen(function*() {
+        let clientSpan: Tracer.NativeSpan | undefined
+        const tracer = Tracer.make({
+          span(options) {
+            clientSpan = new Tracer.NativeSpan(options)
+            return clientSpan
+          }
+        })
+        const client = HttpClient.make((request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              new Response(null, {
+                headers: {
+                  "x-response-drop": "drop",
+                  "x-response-keep": "keep"
+                }
+              })
+            )
+          )
+        )
+
+        yield* client.get("http://test/", {
+          headers: {
+            "x-request-drop": "drop",
+            "x-request-keep": "keep"
+          }
+        }).pipe(
+          Effect.provideService(HttpClient.TracerHeaderFilter, (name) => name.endsWith("-keep")),
+          Effect.provideService(Tracer.Tracer, tracer)
+        )
+
+        assert(clientSpan !== undefined)
+        assert.strictEqual(clientSpan.attributes.get("http.request.header.x-request-drop"), undefined)
+        assert.strictEqual(clientSpan.attributes.get("http.request.header.x-request-keep"), "keep")
+        assert.strictEqual(clientSpan.attributes.get("http.response.header.x-response-drop"), undefined)
+        assert.strictEqual(clientSpan.attributes.get("http.response.header.x-response-keep"), "keep")
+      }))
+
+    it.effect("filters the same header name independently by phase", () =>
+      Effect.gen(function*() {
+        let clientSpan: Tracer.NativeSpan | undefined
+        const tracer = Tracer.make({
+          span(options) {
+            clientSpan = new Tracer.NativeSpan(options)
+            return clientSpan
+          }
+        })
+        const client = HttpClient.make((request) =>
+          Effect.succeed(
+            HttpClientResponse.fromWeb(
+              request,
+              new Response(null, {
+                headers: { "x-phase-filter": "response" }
+              })
+            )
+          )
+        )
+
+        yield* client.get("http://test/", {
+          headers: { "x-phase-filter": "request" }
+        }).pipe(
+          Effect.provideService(HttpClient.TracerHeaderFilter, (_name, phase) => phase === "response"),
+          Effect.provideService(Tracer.Tracer, tracer)
+        )
+
+        assert(clientSpan !== undefined)
+        assert.strictEqual(clientSpan.attributes.get("http.request.header.x-phase-filter"), undefined)
+        assert.strictEqual(clientSpan.attributes.get("http.response.header.x-phase-filter"), "response")
+      }))
+  })
+
   describe("followRedirects", () => {
     it.effect("preserves credential headers on same-origin redirects", () =>
       Effect.gen(function*() {