@effect/platform 0.49.4 → 0.50.1

package/src/internal/http/client.ts

@@ -5,14 +5,14 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import type * as Fiber from "effect/Fiber"
 import * as FiberRef from "effect/FiberRef"
-import { constFalse, dual, pipe } from "effect/Function"
+import { constFalse, dual } 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"
 import * as Ref from "effect/Ref"
 import type * as Schedule from "effect/Schedule"
-import type * as Scope from "effect/Scope"
+import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type * as Body from "../../Http/Body.js"
 import type * as Client from "../../Http/Client.js"
@@ -98,34 +98,69 @@ export const make = <A, E, R, R2, E2>(
 export const makeDefault = (
   f: (
     request: ClientRequest.ClientRequest,
+    url: URL,
+    signal: AbortSignal,
     fiber: Fiber.RuntimeFiber<ClientResponse.ClientResponse, Error.HttpClientError>
   ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError, Scope.Scope>
 ): 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(
+  make((effect) =>
+    Effect.flatMap(effect, (request) =>
+      Effect.withFiberRuntime((fiber) => {
+        const scope = Context.unsafeGet(fiber.getFiberRef(FiberRef.currentContext), Scope.Scope)
+        const controller = new AbortController()
+        const addAbort = Scope.addFinalizer(scope, Effect.sync(() => controller.abort()))
+        const urlResult = UrlParams.makeUrl(request.url, request.urlParams)
+        if (urlResult._tag === "Left") {
+          return Effect.fail(new Error.RequestError({ request, reason: "InvalidUrl", error: urlResult.left }))
+        }
+        const url = urlResult.right
+        const tracerDisabled = fiber.getFiberRef(currentTracerDisabledWhen)(request)
+        if (tracerDisabled) {
+          return Effect.zipRight(
+            addAbort,
+            f(request, url, controller.signal, fiber)
+          )
+        }
+        return Effect.zipRight(
+          addAbort,
+          Effect.useSpan(
             `http.client ${request.method}`,
-            {
-              attributes: {
-                "http.method": request.method,
-                "http.url": request.url
+            (span) => {
+              span.attribute("server.address", url.origin)
+              if (url.port !== "") {
+                span.attribute("server.port", +url.port)
               }
-            },
-            (span) =>
-              Effect.withParentSpan(
-                f(internalRequest.setHeaders(request, TraceContext.toHeaders(span)), fiber),
-                span
+              span.attribute("url.full", url.toString())
+              span.attribute("url.path", url.pathname)
+              span.attribute("url.scheme", url.protocol.slice(0, -1))
+              const query = url.search.slice(1)
+              if (query !== "") {
+                span.attribute("url.query", query)
+              }
+              Object.entries(request.headers).forEach(([key, value]) => {
+                span.attribute(`http.request.header.${key}`, value)
+              })
+              return Effect.tap(
+                Effect.withParentSpan(
+                  f(
+                    internalRequest.setHeaders(request, TraceContext.toHeaders(span)),
+                    url,
+                    controller.signal,
+                    fiber
+                  ),
+                  span
+                ),
+                (response) => {
+                  span.attribute("http.response.status_code", response.status)
+                  Object.entries(response.headers).forEach(([key, value]) => {
+                    span.attribute(`http.response.header.${key}`, value)
+                  })
+                }
               )
+            }
           )
-        })),
-    Effect.succeed as Client.Client.Preprocess<never, never>
-  )
+        )
+      })), Effect.succeed as Client.Client.Preprocess<never, never>)
 
 /** @internal */
 export const Fetch = Context.GenericTag<Client.Fetch, typeof globalThis.fetch>(
@@ -133,52 +168,36 @@ export const Fetch = Context.GenericTag<Client.Fetch, typeof globalThis.fetch>(
 )
 
 /** @internal */
-export const fetch: Client.Client.Default = makeDefault((request, fiber) => {
+export const fetch: Client.Client.Default = makeDefault((request, url, signal, fiber) => {
   const context = fiber.getFiberRef(FiberRef.currentContext)
   const fetch: typeof globalThis.fetch = context.unsafeMap.get(Fetch.key) ?? globalThis.fetch
   const options = fiber.getFiberRef(currentFetchOptions)
-  return Effect.flatMap(
-    UrlParams.makeUrl(request.url, request.urlParams, (_) =>
-      new Error.RequestError({
-        request,
-        reason: "InvalidUrl",
-        error: _
-      })),
-    (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 headers = new Headers(request.headers)
+  const send = (body: BodyInit | undefined) =>
+    Effect.map(
+      Effect.tryPromise({
+        try: () =>
+          fetch(url, {
+            ...options,
+            method: request.method,
+            headers,
+            body,
+            duplex: request.body._tag === "Stream" ? "half" : undefined,
+            signal
+          } as any),
+        catch: (error) =>
+          new Error.RequestError({
+            request,
+            reason: "Transport",
+            error
+          })
+      }),
+      (response) => internalResponse.fromWeb(request, response)
+    )
+  if (Method.hasBody(request.method)) {
+    return send(convertBody(request.body))
+  }
+  return send(undefined)
 })
 
 const convertBody = (body: Body.Body): BodyInit | undefined => {

package/src/internal/http/clientResponse.ts

@@ -212,6 +212,10 @@ export const urlParamsBody = <E, R>(effect: Effect.Effect<ClientResponse.ClientR
 export const formData = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
   Effect.scoped(Effect.flatMap(effect, (_) => _.formData))
 
+/** @internal */
+export const void_ = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.asVoid(effect))
+
 /** @internal */
 export const stream = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
   Stream.unwrapScoped(Effect.map(effect, (_) => _.stream))

package/src/internal/http/middleware.ts

@@ -1,4 +1,3 @@
-import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
@@ -75,25 +74,24 @@ export const logger = make((httpApp) => {
     const context = fiber.getFiberRef(FiberRef.currentContext)
     const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
     return Effect.withLogSpan(
-      Effect.onExit(httpApp, (exit) => {
+      Effect.flatMap(Effect.exit(httpApp), (exit) => {
         if (fiber.getFiberRef(loggerDisabled)) {
-          return Effect.void
+          return exit
         }
-        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
-          })
+        return Effect.zipRight(
+          exit._tag === "Failure" ?
+            Effect.annotateLogs(Effect.log(exit.cause), {
+              "http.method": request.method,
+              "http.url": request.url,
+              "http.status": ServerError.causeStatusCode(exit.cause)
+            }) :
+            Effect.annotateLogs(Effect.log("Sent HTTP response"), {
+              "http.method": request.method,
+              "http.url": request.url,
+              "http.status": exit.value.status
+            }),
+          exit
+        )
       }),
       `http.span.${++counter}`
     )
@@ -109,16 +107,52 @@ export const tracer = make((httpApp) =>
     if (disabled) {
       return httpApp
     }
-    const appWithStatus = Effect.tap(
-      httpApp,
-      (response) => Effect.annotateCurrentSpan("http.status", response.status)
-    )
-    return Effect.withSpan(
-      appWithStatus,
+    const host = request.headers["host"] ?? "localhost"
+    const protocol = request.headers["x-forwarded-proto"] === "https" ? "https" : "http"
+    let url: URL | undefined = undefined
+    try {
+      url = new URL(request.url, `${protocol}://${host}`)
+    } catch (_) {
+      //
+    }
+    return Effect.useSpan(
       `http.server ${request.method}`,
-      {
-        attributes: { "http.method": request.method, "http.url": request.url },
-        parent: Option.getOrUndefined(TraceContext.fromHeaders(request.headers))
+      { parent: Option.getOrUndefined(TraceContext.fromHeaders(request.headers)) },
+      (span) => {
+        span.attribute("http.request.method", request.method)
+        if (url !== undefined) {
+          span.attribute("url.full", url.toString())
+          span.attribute("url.path", url.pathname)
+          const query = url.search.slice(1)
+          if (query !== "") {
+            span.attribute("url.query", url.search.slice(1))
+          }
+          span.attribute("url.scheme", url.protocol.slice(0, -1))
+        }
+        if (request.headers["user-agent"] !== undefined) {
+          span.attribute("user_agent.original", request.headers["user-agent"])
+        }
+        Object.entries(request.headers).forEach(([key, value]) => {
+          span.attribute(`http.request.header.${key}`, value)
+        })
+        if (request.remoteAddress._tag === "Some") {
+          span.attribute("client.address", request.remoteAddress.value)
+        }
+        return Effect.flatMap(
+          Effect.exit(Effect.withParentSpan(httpApp, span)),
+          (exit) => {
+            if (exit._tag === "Failure") {
+              span.attribute("http.response.status_code", ServerError.causeStatusCode(exit.cause))
+            } else {
+              const response = exit.value
+              span.attribute("http.response.status_code", response.status)
+              Object.entries(response.headers).forEach(([key, value]) => {
+                span.attribute(`http.response.header.${key}`, value)
+              })
+            }
+            return exit
+          }
+        )
       }
     )
   })

package/src/internal/http/router.ts

@@ -10,6 +10,7 @@ import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
+import * as Tracer from "effect/Tracer"
 import * as FindMyWay from "find-my-way-ts"
 import type * as App from "../../Http/App.js"
 import type * as Method from "../../Http/Method.js"
@@ -242,6 +243,12 @@ const toHttpApp = <R, E>(
       context = Context.add(context, ServerRequest.ServerRequest, sliceRequestUrl(request, route.prefix.value))
     }
     context = Context.add(context, RouteContext, new RouteContextImpl(route, result.params, result.searchParams))
+
+    const span = Context.getOption(context, Tracer.ParentSpan)
+    if (span._tag === "Some" && span.value._tag === "Span") {
+      span.value.attribute("http.route", route.path)
+    }
+
     return Effect.locally(
       (route.uninterruptible ?
         route.handler :

package/src/internal/http/serverError.ts

@@ -26,3 +26,12 @@ export const isClientAbortCause = <E>(cause: Cause.Cause<E>): boolean =>
     false,
     (_, cause) => cause._tag === "Interrupt" && cause.fiberId === clientAbortFiberId ? Option.some(true) : Option.none()
   )
+
+/** @internal */
+
+export const causeStatusCode = <E>(cause: Cause.Cause<E>): number =>
+  Cause.isInterruptedOnly(cause) ?
+    isClientAbortCause(cause) ?
+      499 :
+      503 :
+    500