@effect/platform 0.15.2 → 0.16.1

package/src/Http/IncomingMessage.ts

@@ -1,15 +1,17 @@
 /**
  * @since 1.0.0
  */
-import { dual } from "@effect/data/Function"
+import * as Context from "@effect/data/Context"
+import { dual, flow } from "@effect/data/Function"
 import * as Global from "@effect/data/GlobalValue"
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import * as FiberRef from "@effect/io/FiberRef"
+import type { ExternalSpan } from "@effect/io/Tracer"
 import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Headers from "@effect/platform/Http/Headers"
 import type * as UrlParams from "@effect/platform/Http/UrlParams"
-import type * as ParseResult from "@effect/schema/ParseResult"
+import * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
 
@@ -32,6 +34,7 @@ export type TypeId = typeof TypeId
 export interface IncomingMessage<E> {
   readonly [TypeId]: TypeId
   readonly headers: Headers.Headers
+  readonly remoteAddress: Option.Option<string>
   readonly json: Effect.Effect<never, E, unknown>
   readonly text: Effect.Effect<never, E, string>
   readonly urlParamsBody: Effect.Effect<never, E, UrlParams.UrlParams>
@@ -68,6 +71,63 @@ export const schemaHeaders = <I extends Readonly<Record<string, string>>, A>(sch
   return <E>(self: IncomingMessage<E>): Effect.Effect<never, ParseResult.ParseError, A> => parse(self.headers)
 }
 
+const SpanSchema = Schema.struct({
+  traceId: Schema.string,
+  spanId: Schema.string,
+  parentSpanId: Schema.union(Schema.string, Schema.undefined)
+})
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaExternalSpan = flow(
+  schemaHeaders(Schema.union(
+    Schema.transformOrFail(
+      Schema.struct({
+        b3: Schema.NonEmpty
+      }),
+      SpanSchema,
+      (_) => {
+        const parts = _.b3.split("-")
+        if (parts.length >= 2) {
+          return ParseResult.success({
+            traceId: parts[0],
+            spanId: parts[1],
+            parentSpanId: parts[3]
+          })
+        }
+        return ParseResult.failure(ParseResult.missing)
+      },
+      (_) => ParseResult.success("")
+    ),
+    Schema.transform(
+      Schema.struct({
+        "x-b3-traceid": Schema.NonEmpty,
+        "x-b3-spanid": Schema.NonEmpty,
+        "x-b3-parentspanid": Schema.optional(Schema.NonEmpty)
+      }),
+      SpanSchema,
+      (_) => ({
+        traceId: _["x-b3-traceid"],
+        spanId: _["x-b3-spanid"],
+        parentSpanId: _["x-b3-parentspanid"]
+      }),
+      (_) => ({
+        "x-b3-traceid": _.traceId,
+        "x-b3-spanid": _.spanId,
+        "x-b3-parentspanid": _.parentSpanId
+      })
+    )
+  )),
+  Effect.map((_): ExternalSpan => ({
+    _tag: "ExternalSpan",
+    traceId: _.traceId,
+    spanId: _.spanId,
+    context: Context.empty()
+  }))
+)
+
 /**
  * @since 1.0.0
  * @category fiber refs

package/src/Http/Middleware.ts

@@ -30,6 +30,12 @@ export declare namespace Middleware {
  */
 export const make: <M extends Middleware>(middleware: M) => M = internal.make
 
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const b3Response: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.b3Response
+
 /**
  * @since 1.0.0
  * @category constructors

package/src/Http/ServerRequest.ts

@@ -49,8 +49,13 @@ export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.Req
   readonly formData: Effect.Effect<Scope.Scope | FileSystem.FileSystem | Path.Path, FormData.FormDataError, FormData>
   readonly formDataStream: Stream.Stream<never, FormData.FormDataError, FormData.Part>
 
-  readonly setUrl: (url: string) => ServerRequest
-  readonly replaceHeaders: (headers: Headers.Headers) => ServerRequest
+  readonly modify: (
+    options: {
+      readonly url?: string
+      readonly headers?: Headers.Headers
+      readonly remoteAddress?: string
+    }
+  ) => ServerRequest
 }
 
 /**

package/src/internal/http/client.ts

@@ -1,15 +1,18 @@
 import * as Context from "@effect/data/Context"
-import { dual } from "@effect/data/Function"
+import { dual, pipe } from "@effect/data/Function"
+import * as Option from "@effect/data/Option"
 import { pipeArguments } from "@effect/data/Pipeable"
 import type * as Predicate from "@effect/data/Predicate"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
 import type * as Schedule from "@effect/io/Schedule"
+import type * as Scope from "@effect/io/Scope"
 import type * as Body from "@effect/platform/Http/Body"
 import type * as Client from "@effect/platform/Http/Client"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
 import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
+import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
 import * as Method from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
@@ -359,6 +362,35 @@ export const mapRequestEffect = dual<
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => setProto((request) => Effect.flatMap(f(request), self)))
 
+/** @internal */
+export const withB3Propagation = <R, E>(
+  self: Client.Client.WithResponse<R, E>
+): Client.Client.WithResponse<R | Scope.Scope, E> =>
+  setProto((req) =>
+    pipe(
+      Effect.map(
+        Effect.currentSpan,
+        Option.match({
+          onNone: () => req,
+          onSome: (span) => {
+            const parentId = span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
+            return internalRequest.setHeader(
+              req,
+              "b3",
+              `${span.traceId}-${span.spanId}-1${parentId}`
+            )
+          }
+        })
+      ),
+      Effect.flatMap(self),
+      Effect.tap((res) =>
+        Effect.ignore(
+          Effect.flatMap(IncomingMessage.schemaExternalSpan(res), Effect.withParentSpanScoped)
+        )
+      )
+    )
+  )
+
 /** @internal */
 export const retry: {
   <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(

package/src/internal/http/clientResponse.ts

@@ -1,3 +1,4 @@
+import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
@@ -39,6 +40,10 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     return Headers.fromInput(this.source.headers)
   }
 
+  get remoteAddress(): Option.Option<string> {
+    return Option.none()
+  }
+
   get stream(): Stream.Stream<never, Error.ResponseError, Uint8Array> {
     return this.source.body
       ? Stream.fromReadableStream(() => this.source.body!, (_) =>

package/src/internal/http/middleware.ts

@@ -1,8 +1,10 @@
 import { flow } from "@effect/data/Function"
 import * as Effect from "@effect/io/Effect"
 import * as Headers from "@effect/platform/Http/Headers"
+import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
 import type * as Middleware from "@effect/platform/Http/Middleware"
 import * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import * as ServerResponse from "@effect/platform/Http/ServerResponse"
 
 /** @internal */
 export const make = <M extends Middleware.Middleware>(middleware: M): M => middleware
@@ -36,26 +38,51 @@ export const tracer = make((httpApp) =>
   Effect.flatMap(
     ServerRequest.ServerRequest,
     (request) =>
-      Effect.withSpan(
-        Effect.tap(
-          httpApp,
-          (response) => Effect.annotateCurrentSpan("http.status", response.status)
-        ),
-        `http ${request.method}`,
-        { attributes: { "http.method": request.method, "http.url": request.url } }
+      Effect.flatMap(
+        Effect.orElseSucceed(IncomingMessage.schemaExternalSpan(request), () => undefined),
+        (parent) =>
+          Effect.withSpan(
+            Effect.tap(
+              httpApp,
+              (response) => Effect.annotateCurrentSpan("http.status", response.status)
+            ),
+            `http ${request.method}`,
+            { attributes: { "http.method": request.method, "http.url": request.url }, parent }
+          )
       )
   )
 )
 
+/** @internal */
+export const b3Response = make((httpApp) =>
+  Effect.flatMap(
+    Effect.currentSpan,
+    (span) =>
+      span._tag === "Some"
+        ? Effect.map(httpApp, (res) =>
+          ServerResponse.setHeader(
+            res,
+            "b3",
+            `${span.value.traceId}-${span.value.spanId}-1${
+              span.value.parent._tag === "Some" ? `-${span.value.parent.value.spanId}` : ""
+            }`
+          ))
+        : httpApp
+  )
+)
+
 /** @internal */
 export const xForwardedHeaders = make((httpApp) =>
   Effect.updateService(httpApp, ServerRequest.ServerRequest, (request) =>
     request.headers["x-forwarded-host"]
-      ? request.replaceHeaders(Headers.set(
-        request.headers,
-        "host",
-        request.headers["x-forwarded-host"]
-      ))
+      ? request.modify({
+        headers: Headers.set(
+          request.headers,
+          "host",
+          request.headers["x-forwarded-host"]
+        ),
+        remoteAddress: request.headers["x-forwarded-for"]?.split(",")[0].trim()
+      })
       : request)
 )
 

package/src/internal/http/router.ts

@@ -3,6 +3,7 @@ import * as Context from "@effect/data/Context"
 import * as Equal from "@effect/data/Equal"
 import { dual } from "@effect/data/Function"
 import * as Hash from "@effect/data/Hash"
+import * as Inspectable from "@effect/data/Inspectable"
 import * as Option from "@effect/data/Option"
 import { pipeArguments } from "@effect/data/Pipeable"
 import type * as Cause from "@effect/io/Cause"
@@ -91,6 +92,19 @@ class RouterImpl<R, E> implements Router.Router<R, E> {
   [Hash.symbol](this: RouterImpl<R, E>): number {
     return Hash.random(this)
   }
+  toJSON() {
+    return {
+      _id: "Router",
+      routes: this.routes.toJSON(),
+      mounts: this.mounts.toJSON()
+    }
+  }
+  toString() {
+    return Inspectable.toString(this)
+  }
+  [Inspectable.NodeInspectSymbol]() {
+    return this.toJSON()
+  }
 }
 
 const toHttpApp = <R, E>(
@@ -151,7 +165,7 @@ const toHttpApp = <R, E>(
 
 function sliceRequestUrl(request: ServerRequest.ServerRequest, prefix: string) {
   const prefexLen = prefix.length
-  return request.setUrl(request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen))
+  return request.modify({ url: request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen) })
 }
 
 class RouteImpl<R, E> implements Router.Route<R, E> {