@effect/platform 0.48.22 → 0.48.24

package/src/Http/IncomingMessage.ts

@@ -2,17 +2,15 @@
  * @since 1.0.0
  */
 import type { ParseOptions } from "@effect/schema/AST"
-import * as ParseResult from "@effect/schema/ParseResult"
+import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
-import { dual, flow } from "effect/Function"
+import { dual } from "effect/Function"
 import * as Global from "effect/GlobalValue"
 import type { Inspectable } from "effect/Inspectable"
 import * as Option from "effect/Option"
 import type * as Stream from "effect/Stream"
-import * as Tracer from "effect/Tracer"
-import type { ExternalSpan } from "effect/Tracer"
 import * as FileSystem from "../FileSystem.js"
 import type * as Headers from "./Headers.js"
 import type * as UrlParams from "./UrlParams.js"
@@ -112,73 +110,6 @@ export const schemaHeadersEffect = <R, I extends Readonly<Record<string, string>
   return <E, E2, R2>(effect: Effect.Effect<IncomingMessage<E>, E2, R2>) => Effect.scoped(Effect.flatMap(effect, decode))
 }
 
-const SpanSchema = Schema.struct({
-  traceId: Schema.string,
-  spanId: Schema.string,
-  parentSpanId: Schema.union(Schema.string, Schema.undefined),
-  sampled: Schema.boolean
-})
-
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaExternalSpan: <E>(
-  self: IncomingMessage<E>
-) => Effect.Effect<Tracer.ExternalSpan, ParseResult.ParseError> = flow(
-  schemaHeaders(Schema.union(
-    Schema.transformOrFail(
-      Schema.struct({
-        b3: Schema.NonEmpty
-      }),
-      SpanSchema,
-      (input, _, ast) => {
-        const parts = input.b3.split("-")
-        if (parts.length >= 2) {
-          return ParseResult.succeed(
-            {
-              traceId: parts[0],
-              spanId: parts[1],
-              sampled: parts[2] ? parts[2] === "1" : true,
-              parentSpanId: parts[3]
-            } as const
-          )
-        }
-        return ParseResult.fail(new ParseResult.Type(ast, input))
-      },
-      (_) => ParseResult.succeed({ b3: "" } as const)
-    ),
-    Schema.transform(
-      Schema.struct({
-        "x-b3-traceid": Schema.NonEmpty,
-        "x-b3-spanid": Schema.NonEmpty,
-        "x-b3-parentspanid": Schema.optional(Schema.NonEmpty),
-        "x-b3-sampled": Schema.optional(Schema.NonEmpty, { default: () => "1" })
-      }),
-      SpanSchema,
-      (_) => ({
-        traceId: _["x-b3-traceid"],
-        spanId: _["x-b3-spanid"],
-        parentSpanId: _["x-b3-parentspanid"],
-        sampled: _["x-b3-sampled"] === "1"
-      } as const),
-      (_) => ({
-        "x-b3-traceid": _.traceId,
-        "x-b3-spanid": _.spanId,
-        "x-b3-parentspanid": _.parentSpanId,
-        "x-b3-sampled": _.sampled ? "1" : "0"
-      } as const)
-    )
-  )),
-  Effect.map((_): ExternalSpan =>
-    Tracer.externalSpan({
-      traceId: _.traceId,
-      spanId: _.spanId,
-      sampled: _.sampled
-    })
-  )
-)
-
 /**
  * @since 1.0.0
  * @category fiber refs

package/src/Http/Router.ts

@@ -155,20 +155,22 @@ export const searchParams: Effect.Effect<
  */
 export const schemaJson: <
   R,
-  I extends {
-    readonly method?: Method.Method | undefined
-    readonly url?: string | undefined
-    readonly cookies?: Readonly<Record<string, string>> | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-    readonly pathParams?: Readonly<Record<string, string>> | undefined
-    readonly searchParams?: Readonly<Record<string, string>> | undefined
-    readonly body?: any
-  },
+  I extends Partial<
+    {
+      readonly method: Method.Method
+      readonly url: string
+      readonly cookies: Readonly<Record<string, string>>
+      readonly headers: Readonly<Record<string, string>>
+      readonly pathParams: Readonly<Record<string, string>>
+      readonly searchParams: Readonly<Record<string, string>>
+      readonly body: any
+    }
+  >,
   A
 >(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
-) => Effect.Effect<A, ParseResult.ParseError | Error.RequestError, RouteContext | R | ServerRequest.ServerRequest> =
+) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, RouteContext | R | ServerRequest.ServerRequest> =
   internal.schemaJson
 
 /**
@@ -177,20 +179,19 @@ export const schemaJson: <
  */
 export const schemaNoBody: <
   R,
-  I extends {
-    readonly method?: Method.Method | undefined
-    readonly url?: string | undefined
-    readonly cookies?: Readonly<Record<string, string>> | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-    readonly pathParams?: Readonly<Record<string, string>> | undefined
-    readonly searchParams?: Readonly<Record<string, string>> | undefined
-  },
+  I extends Partial<{
+    readonly method: Method.Method
+    readonly url: string
+    readonly cookies: Readonly<Record<string, string>>
+    readonly headers: Readonly<Record<string, string>>
+    readonly pathParams: Readonly<Record<string, string>>
+    readonly searchParams: Readonly<Record<string, string>>
+  }>,
   A
 >(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
-) => Effect.Effect<A, ParseResult.ParseError | Error.RequestError, RouteContext | R | ServerRequest.ServerRequest> =
-  internal.schemaNoBody
+) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext | ServerRequest.ServerRequest> = internal.schemaNoBody
 
 /**
  * @since 1.0.0

package/src/Http/TraceContext.ts

@@ -0,0 +1,109 @@
+/**
+ * @since 1.0.0
+ */
+import * as Option from "effect/Option"
+import * as Tracer from "effect/Tracer"
+import * as Headers from "./Headers.js"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface FromHeaders {
+  (headers: Headers.Headers): Option.Option<Tracer.ExternalSpan>
+}
+
+/**
+ * @since 1.0.0
+ * @category encoding
+ */
+export const toHeaders = (span: Tracer.Span): Headers.Headers =>
+  Headers.unsafeFromRecord({
+    b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
+      span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
+    }`,
+    traceparent: `00-${span.traceId}-${span.spanId}-${span.sampled ? "01" : "00"}`
+  })
+
+/**
+ * @since 1.0.0
+ * @category decoding
+ */
+export const fromHeaders = (headers: Headers.Headers): Option.Option<Tracer.ExternalSpan> => {
+  let span = w3c(headers)
+  if (span._tag === "Some") {
+    return span
+  }
+  span = b3(headers)
+  if (span._tag === "Some") {
+    return span
+  }
+  return xb3(headers)
+}
+
+/**
+ * @since 1.0.0
+ * @category decoding
+ */
+export const b3: FromHeaders = (headers) => {
+  if (!("b3" in headers)) {
+    return Option.none()
+  }
+  const parts = headers["b3"].split("-")
+  if (parts.length < 2) {
+    return Option.none()
+  }
+  return Option.some(Tracer.externalSpan({
+    traceId: parts[0],
+    spanId: parts[1],
+    sampled: parts[2] ? parts[2] === "1" : true
+  }))
+}
+
+/**
+ * @since 1.0.0
+ * @category decoding
+ */
+export const xb3: FromHeaders = (headers) => {
+  if (!(headers["x-b3-traceid"]) || !(headers["x-b3-spanid"])) {
+    return Option.none()
+  }
+  return Option.some(Tracer.externalSpan({
+    traceId: headers["x-b3-traceid"],
+    spanId: headers["x-b3-spanid"],
+    sampled: headers["x-b3-sampled"] ? headers["x-b3-sampled"] === "1" : true
+  }))
+}
+
+const w3cTraceId = /^[0-9a-f]{32}$/gi
+const w3cSpanId = /^[0-9a-f]{16}$/gi
+
+/**
+ * @since 1.0.0
+ * @category decoding
+ */
+export const w3c: FromHeaders = (headers) => {
+  if (!(headers["traceparent"])) {
+    return Option.none()
+  }
+  const parts = headers["traceparent"].split("-")
+  if (parts.length !== 4) {
+    return Option.none()
+  }
+  const [version, traceId, spanId, flags] = parts
+  switch (version) {
+    case "00": {
+      if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false) {
+        return Option.none()
+      }
+      return Option.some(Tracer.externalSpan({
+        traceId,
+        spanId,
+        sampled: (parseInt(flags, 16) & 1) === 1
+      }))
+    }
+    default: {
+      return Option.none()
+    }
+  }
+}

package/src/internal/http/client.ts

@@ -3,7 +3,10 @@ import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import { dual, pipe } from "effect/Function"
+import type * as Fiber from "effect/Fiber"
+import * as FiberRef from "effect/FiberRef"
+import { constFalse, dual, pipe } from "effect/Function"
+import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import { pipeArguments } from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
@@ -18,6 +21,7 @@ import type * as ClientRequest from "../../Http/ClientRequest.js"
 import type * as ClientResponse from "../../Http/ClientResponse.js"
 import * as Cookies from "../../Http/Cookies.js"
 import * as Method from "../../Http/Method.js"
+import * as TraceContext from "../../Http/TraceContext.js"
 import * as UrlParams from "../../Http/UrlParams.js"
 import * as internalBody from "./body.js"
 import * as internalRequest from "./clientRequest.js"
@@ -31,6 +35,23 @@ export const TypeId: Client.TypeId = Symbol.for(
 /** @internal */
 export const tag = Context.GenericTag<Client.Client.Default>("@effect/platform/Http/Client")
 
+/** @internal */
+export const currentTracerDisabledWhen = globalValue(
+  Symbol.for("@effect/platform/Http/Client/tracerDisabledWhen"),
+  () => FiberRef.unsafeMake<Predicate.Predicate<ClientRequest.ClientRequest>>(constFalse)
+)
+
+/** @internal */
+export const withTracerDisabledWhen = dual<
+  (
+    predicate: Predicate.Predicate<ClientRequest.ClientRequest>
+  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <R, E, A>(
+    effect: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<ClientRequest.ClientRequest>
+  ) => Effect.Effect<A, E, R>
+>(2, (self, pred) => Effect.locally(self, currentTracerDisabledWhen, pred))
+
 const clientProto = {
   [TypeId]: TypeId,
   pipe() {
@@ -56,25 +77,38 @@ export const make = <R, E, A, R2, E2>(
   return client as any
 }
 
-const addB3Headers = (req: ClientRequest.ClientRequest) =>
-  Effect.match(Effect.currentSpan, {
-    onFailure: () => req,
-    onSuccess: (span) =>
-      internalRequest.setHeader(
-        req,
-        "b3",
-        `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
-          span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
-        }`
-      )
-  })
-
 /** @internal */
 export const makeDefault = (
   f: (
-    request: ClientRequest.ClientRequest
+    request: ClientRequest.ClientRequest,
+    fiber: Fiber.RuntimeFiber<ClientResponse.ClientResponse, Error.HttpClientError>
   ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError, Scope.Scope>
-): Client.Client.Default => make(Effect.flatMap(f), addB3Headers)
+): Client.Client.Default =>
+  make(
+    (effect) =>
+      Effect.flatMap(effect, (request) =>
+        Effect.withFiberRuntime((fiber) => {
+          const tracerDisabled = fiber.getFiberRef(currentTracerDisabledWhen)(request)
+          if (tracerDisabled) {
+            return f(request, fiber)
+          }
+          return Effect.useSpan(
+            `http.client ${request.method}`,
+            {
+              attributes: {
+                "http.method": request.method,
+                "http.url": request.url
+              }
+            },
+            (span) =>
+              Effect.withParentSpan(
+                f(internalRequest.setHeaders(request, TraceContext.toHeaders(span)), fiber),
+                span
+              )
+          )
+        })),
+    Effect.succeed as Client.Client.Preprocess<never, never>
+  )
 
 /** @internal */
 export const Fetch = Context.GenericTag<Client.Fetch, typeof globalThis.fetch>(
@@ -83,52 +117,52 @@ export const Fetch = Context.GenericTag<Client.Fetch, typeof globalThis.fetch>(
 
 /** @internal */
 export const fetch = (options?: RequestInit): Client.Client.Default =>
-  makeDefault((request) =>
-    Effect.flatMap(
+  makeDefault((request, fiber) => {
+    const context = fiber.getFiberRef(FiberRef.currentContext)
+    const fetch: typeof globalThis.fetch = context.unsafeMap.get(Fetch.key) ?? globalThis.fetch
+    return Effect.flatMap(
       UrlParams.makeUrl(request.url, request.urlParams, (_) =>
         new Error.RequestError({
           request,
           reason: "InvalidUrl",
           error: _
         })),
-      (url) =>
-        Effect.flatMap(Effect.serviceOption(Fetch), (fetch_) => {
-          const fetch = fetch_._tag === "Some" ? fetch_.value : globalThis.fetch
-          const headers = new Headers(request.headers)
-          const send = (body: BodyInit | undefined) =>
-            pipe(
-              Effect.acquireRelease(
-                Effect.sync(() => new AbortController()),
-                (controller) => Effect.sync(() => controller.abort())
-              ),
-              Effect.flatMap((controller) =>
-                Effect.tryPromise({
-                  try: () =>
-                    fetch(url, {
-                      ...options,
-                      method: request.method,
-                      headers,
-                      body,
-                      duplex: request.body._tag === "Stream" ? "half" : undefined,
-                      signal: controller.signal
-                    } as any),
-                  catch: (_) =>
-                    new Error.RequestError({
-                      request,
-                      reason: "Transport",
-                      error: _
-                    })
-                })
-              ),
-              Effect.map((_) => internalResponse.fromWeb(request, _))
-            )
-          if (Method.hasBody(request.method)) {
-            return send(convertBody(request.body))
-          }
-          return send(undefined)
-        })
+      (url) => {
+        const headers = new Headers(request.headers)
+        const send = (body: BodyInit | undefined) =>
+          pipe(
+            Effect.acquireRelease(
+              Effect.sync(() => new AbortController()),
+              (controller) => Effect.sync(() => controller.abort())
+            ),
+            Effect.flatMap((controller) =>
+              Effect.tryPromise({
+                try: () =>
+                  fetch(url, {
+                    ...options,
+                    method: request.method,
+                    headers,
+                    body,
+                    duplex: request.body._tag === "Stream" ? "half" : undefined,
+                    signal: controller.signal
+                  } as any),
+                catch: (_) =>
+                  new Error.RequestError({
+                    request,
+                    reason: "Transport",
+                    error: _
+                  })
+              })
+            ),
+            Effect.map((_) => internalResponse.fromWeb(request, _))
+          )
+        if (Method.hasBody(request.method)) {
+          return send(convertBody(request.body))
+        }
+        return send(undefined)
+      }
     )
-  )
+  })
 
 const convertBody = (body: Body.Body): BodyInit | undefined => {
   switch (body._tag) {

package/src/internal/http/middleware.ts

@@ -1,14 +1,16 @@
 import * as Cause from "effect/Cause"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import { constFalse, dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
+import * as Option from "effect/Option"
 import type * as Predicate from "effect/Predicate"
 import * as Headers from "../../Http/Headers.js"
-import * as IncomingMessage from "../../Http/IncomingMessage.js"
 import type * as Middleware from "../../Http/Middleware.js"
 import * as ServerError from "../../Http/ServerError.js"
 import * as ServerRequest from "../../Http/ServerRequest.js"
+import * as TraceContext from "../../Http/TraceContext.js"
 
 /** @internal */
 export const make = <M extends Middleware.Middleware>(middleware: M): M => middleware
@@ -46,37 +48,33 @@ export const withTracerDisabledWhen = dual<
 /** @internal */
 export const logger = make((httpApp) => {
   let counter = 0
-  return Effect.flatMap(
-    ServerRequest.ServerRequest,
-    (request) =>
-      Effect.withLogSpan(
-        Effect.onExit(httpApp, (exit) =>
-          Effect.flatMap(
-            FiberRef.get(loggerDisabled),
-            (disabled) => {
-              if (disabled) {
-                return Effect.unit
-              }
-              return exit._tag === "Failure" ?
-                Effect.annotateLogs(Effect.log(exit.cause), {
-                  "http.method": request.method,
-                  "http.url": request.url,
-                  "http.status": Cause.isInterruptedOnly(exit.cause)
-                    ? ServerError.isClientAbortCause(exit.cause)
-                      ? 499
-                      : 503
-                    : 500
-                }) :
-                Effect.annotateLogs(Effect.log("Sent HTTP response"), {
-                  "http.method": request.method,
-                  "http.url": request.url,
-                  "http.status": exit.value.status
-                })
-            }
-          )),
-        `http.span.${++counter}`
-      )
-  )
+  return Effect.withFiberRuntime((fiber) => {
+    const context = fiber.getFiberRef(FiberRef.currentContext)
+    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    return Effect.withLogSpan(
+      Effect.onExit(httpApp, (exit) => {
+        if (fiber.getFiberRef(loggerDisabled)) {
+          return Effect.unit
+        }
+        return exit._tag === "Failure" ?
+          Effect.annotateLogs(Effect.log(exit.cause), {
+            "http.method": request.method,
+            "http.url": request.url,
+            "http.status": Cause.isInterruptedOnly(exit.cause)
+              ? ServerError.isClientAbortCause(exit.cause)
+                ? 499
+                : 503
+              : 500
+          }) :
+          Effect.annotateLogs(Effect.log("Sent HTTP response"), {
+            "http.method": request.method,
+            "http.url": request.url,
+            "http.status": exit.value.status
+          })
+      }),
+      `http.span.${++counter}`
+    )
+  })
 })
 
 /** @internal */
@@ -85,23 +83,22 @@ export const tracer = make((httpApp) => {
     httpApp,
     (response) => Effect.annotateCurrentSpan("http.status", response.status)
   )
-  return Effect.flatMap(
-    Effect.zip(ServerRequest.ServerRequest, FiberRef.get(currentTracerDisabledWhen)),
-    ([request, disabledWhen]) =>
-      Effect.flatMap(
-        request.headers["x-b3-traceid"] || request.headers["b3"] ?
-          Effect.orElseSucceed(IncomingMessage.schemaExternalSpan(request), () => undefined) :
-          Effect.succeed(undefined),
-        (parent) =>
-          disabledWhen(request) ?
-            httpApp :
-            Effect.withSpan(
-              appWithStatus,
-              `http ${request.method}`,
-              { attributes: { "http.method": request.method, "http.url": request.url }, parent }
-            )
-      )
-  )
+  return Effect.withFiberRuntime((fiber) => {
+    const context = fiber.getFiberRef(FiberRef.currentContext)
+    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    const disabled = fiber.getFiberRef(currentTracerDisabledWhen)(request)
+    if (disabled) {
+      return httpApp
+    }
+    return Effect.withSpan(
+      appWithStatus,
+      `http.server ${request.method}`,
+      {
+        attributes: { "http.method": request.method, "http.url": request.url },
+        parent: Option.getOrUndefined(TraceContext.fromHeaders(request.headers))
+      }
+    )
+  })
 })
 
 /** @internal */

package/src/internal/http/router.ts

@@ -40,15 +40,15 @@ export const searchParams = Effect.map(RouteContext, (_) => _.searchParams)
 /** @internal */
 export const schemaJson = <
   R,
-  I extends {
-    readonly method?: Method.Method
-    readonly url?: string
-    readonly cookies?: Readonly<Record<string, string>>
-    readonly headers?: Readonly<Record<string, string>>
-    readonly pathParams?: Readonly<Record<string, string>>
-    readonly searchParams?: Readonly<Record<string, string>>
-    readonly body?: any
-  },
+  I extends Partial<{
+    readonly method: Method.Method
+    readonly url: string
+    readonly cookies: Readonly<Record<string, string>>
+    readonly headers: Readonly<Record<string, string>>
+    readonly pathParams: Readonly<Record<string, string>>
+    readonly searchParams: Readonly<Record<string, string>>
+    readonly body: any
+  }>,
   A
 >(
   schema: Schema.Schema<A, I, R>,
@@ -74,14 +74,14 @@ export const schemaJson = <
 /** @internal */
 export const schemaNoBody = <
   R,
-  I extends {
-    readonly method?: Method.Method
-    readonly url?: string
-    readonly cookies?: Readonly<Record<string, string>>
-    readonly headers?: Readonly<Record<string, string>>
-    readonly pathParams?: Readonly<Record<string, string>>
-    readonly searchParams?: Readonly<Record<string, string>>
-  },
+  I extends Partial<{
+    readonly method: Method.Method
+    readonly url: string
+    readonly cookies: Readonly<Record<string, string>>
+    readonly headers: Readonly<Record<string, string>>
+    readonly pathParams: Readonly<Record<string, string>>
+    readonly searchParams: Readonly<Record<string, string>>
+  }>,
   A
 >(
   schema: Schema.Schema<A, I, R>,