effect 2.0.0-next.49 → 2.0.0-next.50

package/src/Stream.ts

@@ -4004,7 +4004,6 @@ export const withSpan: {
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
   ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
@@ -4016,7 +4015,6 @@ export const withSpan: {
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
   ): Stream<R, E, A>

package/src/Tracer.ts

@@ -29,7 +29,6 @@ export interface Tracer {
     parent: Option.Option<ParentSpan>,
     context: Context.Context<never>,
     links: ReadonlyArray<SpanLink>,
-    sampled: boolean,
     startTime: bigint
   ) => Span
   readonly context: <X>(f: () => X, fiber: Fiber.RuntimeFiber<any, any>) => X
@@ -55,6 +54,12 @@ export type SpanStatus = {
  */
 export type ParentSpan = Span | ExternalSpan
 
+/**
+ * @since 2.0.0
+ * @category tags
+ */
+export const ParentSpan: Context.Tag<ParentSpan, ParentSpan> = internal.spanTag
+
 /**
  * @since 2.0.0
  * @category models

package/src/internal/channel.ts

@@ -32,6 +32,7 @@ import * as core from "./core-stream"
 import * as MergeDecisionOpCodes from "./opCodes/channelMergeDecision"
 import * as MergeStateOpCodes from "./opCodes/channelMergeState"
 import * as ChannelStateOpCodes from "./opCodes/channelState"
+import * as tracer from "./tracer"
 
 /** @internal */
 export const acquireUseRelease = <Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone, Acquired>(
@@ -2299,12 +2300,11 @@ export const withSpan = dual<
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
   ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
     self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
+  ) => Channel.Channel<Exclude<Env, Tracer.ParentSpan>, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
   <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
     self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
     name: string,
@@ -2313,11 +2313,20 @@ export const withSpan = dual<
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
-  ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
->(3, (self, name, options) => unwrapScoped(Effect.as(Effect.setSpan(name, options), self)))
+  ) => Channel.Channel<Exclude<Env, Tracer.ParentSpan>, InErr, InElem, InDone, OutErr, OutElem, OutDone>
+>(3, (self, name, options) =>
+  unwrapScoped(
+    Effect.flatMap(
+      Effect.context(),
+      (context) =>
+        Effect.map(
+          Effect.makeSpanScoped(name, options),
+          (span) => core.provideContext(self, Context.add(context, tracer.spanTag, span))
+        )
+    )
+  ) as any)
 
 /** @internal */
 export const writeAll = <OutElem>(

package/src/internal/core-effect.ts

@@ -21,6 +21,7 @@ import * as fiberRefsPatch from "../internal/fiberRefs/patch"
 import * as metricLabel from "../internal/metric/label"
 import * as runtimeFlags from "../internal/runtimeFlags"
 import * as SingleShotGen from "../internal/singleShotGen"
+import * as internalTracer from "../internal/tracer"
 import * as List from "../List"
 import * as LogLevel from "../LogLevel"
 import * as LogSpan from "../LogSpan"
@@ -1189,7 +1190,20 @@ export const provideService = dual<
     tag: T,
     service: Context.Tag.Service<T>
   ) => Effect.Effect<Exclude<R, Context.Tag.Identifier<T>>, E, A>
->(3, (self, tag, service) => provideServiceEffect(self, tag, core.succeed(service)))
+>(
+  3,
+  <R, E, A, T extends Context.Tag<any, any>>(
+    self: Effect.Effect<R, E, A>,
+    tag: T,
+    service: Context.Tag.Service<T>
+  ): Effect.Effect<Exclude<R, Context.Tag.Identifier<T>>, E, A> =>
+    core.contextWithEffect((env) =>
+      core.provideContext(
+        self as Effect.Effect<Context.Tag.Identifier<T> | Exclude<R, Context.Tag.Identifier<T>>, E, A>,
+        Context.add(env, tag, service)
+      )
+    )
+)
 
 /* @internal */
 export const provideServiceEffect = dual<
@@ -1890,6 +1904,9 @@ export const serviceMembers = <I, S>(tag: Context.Tag<I, S>): {
   constants: serviceConstants(tag)
 })
 
+/** @internal */
+export const serviceOption = <I, S>(tag: Context.Tag<I, S>) => core.map(core.context<never>(), Context.getOption(tag))
+
 // -----------------------------------------------------------------------------
 // tracing
 // -----------------------------------------------------------------------------
@@ -1947,16 +1964,18 @@ export const annotateSpans = dual<
   }
 )
 
-/* @internal */
-export const currentParentSpan: Effect.Effect<never, never, Option.Option<Tracer.ParentSpan>> = core.map(
-  core.fiberRefGet(core.currentTracerSpan),
-  List.head
+/** @internal */
+export const currentParentSpan: Effect.Effect<never, never, Option.Option<Tracer.ParentSpan>> = serviceOption(
+  internalTracer.spanTag
 )
 
-/* @internal */
+/** @internal */
 export const currentSpan: Effect.Effect<never, never, Option.Option<Tracer.Span>> = core.map(
-  core.fiberRefGet(core.currentTracerSpan),
-  List.findFirst((span): span is Tracer.Span => span._tag === "Span")
+  core.context<never>(),
+  (context) => {
+    const span = context.unsafeMap.get(internalTracer.spanTag) as Tracer.ParentSpan | undefined
+    return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
+  }
 )
 
 const bigint0 = BigInt(0)
@@ -2001,7 +2020,6 @@ export const makeSpan = (
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
 ) =>
@@ -2031,7 +2049,6 @@ export const makeSpan = (
                         parent,
                         options?.context ?? Context.empty(),
                         linksArray,
-                        options?.sampled ?? (parent._tag === "Some" ? parent.value.sampled : true),
                         startTime
                       )
                       HashMap.forEach(annotations, (value, key) => span.attribute(key, value))
@@ -2060,7 +2077,6 @@ export const useSpan: {
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }, evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
 } = <R, E, A>(
@@ -2075,7 +2091,6 @@ export const useSpan: {
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   } | undefined = args.length === 1 ? undefined : args[0]
   const evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A> = args[args.length - 1]
@@ -2093,14 +2108,11 @@ export const useSpan: {
 
 /** @internal */
 export const withParentSpan = dual<
-  (span: Tracer.ParentSpan) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, span: Tracer.ParentSpan) => Effect.Effect<R, E, A>
->(2, (self, span) =>
-  core.fiberRefLocallyWith(
-    self,
-    core.currentTracerSpan,
-    List.prepend(span)
-  ))
+  (
+    span: Tracer.ParentSpan
+  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<Exclude<R, Tracer.ParentSpan>, E, A>,
+  <R, E, A>(self: Effect.Effect<R, E, A>, span: Tracer.ParentSpan) => Effect.Effect<Exclude<R, Tracer.ParentSpan>, E, A>
+>(2, (self, span) => provideService(self, internalTracer.spanTag, span))
 
 /** @internal */
 export const withSpan = dual<
@@ -2109,17 +2121,15 @@ export const withSpan = dual<
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
-  }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<Exclude<R, Tracer.ParentSpan>, E, A>,
   <R, E, A>(self: Effect.Effect<R, E, A>, name: string, options?: {
     readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
-  }) => Effect.Effect<R, E, A>
+  }) => Effect.Effect<Exclude<R, Tracer.ParentSpan>, E, A>
 >(
   (args) => typeof args[0] !== "string",
   (self, name, options) =>

package/src/internal/core.ts

@@ -27,6 +27,7 @@ import type * as fiberScope from "../internal/fiberScope"
 import * as DeferredOpCodes from "../internal/opCodes/deferred"
 import * as OpCodes from "../internal/opCodes/effect"
 import * as _runtimeFlags from "../internal/runtimeFlags"
+import * as internalTracer from "../internal/tracer"
 import * as List from "../List"
 import type * as LogLevel from "../LogLevel"
 import type * as LogSpan from "../LogSpan"
@@ -617,26 +618,23 @@ export const originalInstance = <E>(obj: E): E => {
 }
 
 /* @internal */
-const capture = <E>(obj: E & object, span: List.List<Tracer.ParentSpan>): E => {
-  if (List.isCons(span)) {
-    const head = span.head
-    if (head._tag === "Span") {
-      return new Proxy(obj, {
-        has(target, p) {
-          return p === spanSymbol || p === originalSymbol || p in target
-        },
-        get(target, p) {
-          if (p === spanSymbol) {
-            return head
-          }
-          if (p === originalSymbol) {
-            return obj
-          }
-          // @ts-expect-error
-          return target[p]
+const capture = <E>(obj: E & object, span: Option.Option<Tracer.Span>): E => {
+  if (Option.isSome(span)) {
+    return new Proxy(obj, {
+      has(target, p) {
+        return p === spanSymbol || p === originalSymbol || p in target
+      },
+      get(target, p) {
+        if (p === spanSymbol) {
+          return span.value
         }
-      })
-    }
+        if (p === originalSymbol) {
+          return obj
+        }
+        // @ts-expect-error
+        return target[p]
+      }
+    })
   }
   return obj
 }
@@ -644,7 +642,7 @@ const capture = <E>(obj: E & object, span: List.List<Tracer.ParentSpan>): E => {
 /* @internal */
 export const die = (defect: unknown): Effect.Effect<never, never, never> =>
   typeof defect === "object" && defect !== null && !(spanSymbol in defect) ?
-    withFiberRuntime((fiber) => failCause(internalCause.die(capture(defect, fiber.getFiberRef(currentTracerSpan)))))
+    withFiberRuntime((fiber) => failCause(internalCause.die(capture(defect, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.die(defect))
 
 /* @internal */
@@ -661,15 +659,6 @@ export const either = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R,
     onSuccess: (a) => succeed(Either.right(a))
   })
 
-/* @internal */
-export const context = <R>(): Effect.Effect<R, never, Context.Context<R>> =>
-  suspend(() => fiberRefGet(currentContext) as Effect.Effect<never, never, Context.Context<R>>)
-
-/* @internal */
-export const contextWithEffect = <R, R0, E, A>(
-  f: (context: Context.Context<R0>) => Effect.Effect<R, E, A>
-): Effect.Effect<R | R0, E, A> => flatMap(context<R0>(), f)
-
 /* @internal */
 export const exit = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R, never, Exit.Exit<E, A>> =>
   matchCause(self, {
@@ -680,7 +669,7 @@ export const exit = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R, ne
 /* @internal */
 export const fail = <E>(error: E): Effect.Effect<never, E, never> =>
   typeof error === "object" && error !== null && !(spanSymbol in error) ?
-    withFiberRuntime((fiber) => failCause(internalCause.fail(capture(error, fiber.getFiberRef(currentTracerSpan)))))
+    withFiberRuntime((fiber) => failCause(internalCause.fail(capture(error, currentSpanFromFiber(fiber)))))
     : failCause(internalCause.fail(error))
 
 /* @internal */
@@ -1095,40 +1084,6 @@ export const partitionMap = <A, A1, A2>(
     [new Array<A1>(), new Array<A2>()]
   )
 
-/* @internal */
-export const provideContext = dual<
-  <R>(context: Context.Context<R>) => <E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<never, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, context: Context.Context<R>) => Effect.Effect<never, E, A>
->(2, <R, E, A>(self: Effect.Effect<R, E, A>, context: Context.Context<R>) =>
-  fiberRefLocally(
-    currentContext,
-    context
-  )(self as Effect.Effect<never, E, A>))
-
-/* @internal */
-export const provideSomeContext = dual<
-  <R>(context: Context.Context<R>) => <R1, E, A>(self: Effect.Effect<R1, E, A>) => Effect.Effect<Exclude<R1, R>, E, A>,
-  <R, R1, E, A>(self: Effect.Effect<R1, E, A>, context: Context.Context<R>) => Effect.Effect<Exclude<R1, R>, E, A>
->(2, <R1, R, E, A>(self: Effect.Effect<R1, E, A>, context: Context.Context<R>) =>
-  fiberRefLocallyWith(
-    currentContext,
-    (parent) => Context.merge(parent, context)
-  )(self as Effect.Effect<never, E, A>))
-
-/* @internal */
-export const mapInputContext = dual<
-  <R0, R>(
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => <E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R0, E, A>,
-  <R0, R, E, A>(
-    self: Effect.Effect<R, E, A>,
-    f: (context: Context.Context<R0>) => Context.Context<R>
-  ) => Effect.Effect<R0, E, A>
->(2, <R0, R, E, A>(
-  self: Effect.Effect<R, E, A>,
-  f: (context: Context.Context<R0>) => Context.Context<R>
-) => contextWithEffect((context: Context.Context<R0>) => provideContext(self, f(context))))
-
 /* @internal */
 export const runtimeFlags: Effect.Effect<never, never, RuntimeFlags.RuntimeFlags> = withFiberRuntime<
   never,
@@ -1931,12 +1886,6 @@ export const currentInterruptedCause: FiberRef.FiberRef<Cause.Cause<never>> = gl
     })
 )
 
-/** @internal */
-export const currentTracerSpan: FiberRef.FiberRef<List.List<Tracer.ParentSpan>> = globalValue(
-  Symbol.for("effect/FiberRef/currentTracerSpan"),
-  () => fiberRefUnsafeMake(List.empty<Tracer.ParentSpan>())
-)
-
 /** @internal */
 export const currentTracerTimingEnabled: FiberRef.FiberRef<boolean> = globalValue(
   Symbol.for("effect/FiberRef/currentTracerTiming"),
@@ -2761,3 +2710,67 @@ const deferredInterruptJoiner = <E, A>(
       )
     }
   })
+
+// -----------------------------------------------------------------------------
+// Context
+// -----------------------------------------------------------------------------
+
+const constContext = fiberRefGet(currentContext)
+
+/* @internal */
+export const context = <R>(): Effect.Effect<R, never, Context.Context<R>> =>
+  constContext as Effect.Effect<never, never, Context.Context<R>>
+
+/* @internal */
+export const contextWith = <R0, A>(
+  f: (context: Context.Context<R0>) => A
+): Effect.Effect<R0, never, A> => map(context<R0>(), f)
+
+/* @internal */
+export const contextWithEffect = <R, R0, E, A>(
+  f: (context: Context.Context<R0>) => Effect.Effect<R, E, A>
+): Effect.Effect<R | R0, E, A> => flatMap(context<R0>(), f)
+
+/* @internal */
+export const provideContext = dual<
+  <R>(context: Context.Context<R>) => <E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<never, E, A>,
+  <R, E, A>(self: Effect.Effect<R, E, A>, context: Context.Context<R>) => Effect.Effect<never, E, A>
+>(2, <R, E, A>(self: Effect.Effect<R, E, A>, context: Context.Context<R>) =>
+  fiberRefLocally(
+    currentContext,
+    context
+  )(self as Effect.Effect<never, E, A>))
+
+/* @internal */
+export const provideSomeContext = dual<
+  <R>(context: Context.Context<R>) => <R1, E, A>(self: Effect.Effect<R1, E, A>) => Effect.Effect<Exclude<R1, R>, E, A>,
+  <R, R1, E, A>(self: Effect.Effect<R1, E, A>, context: Context.Context<R>) => Effect.Effect<Exclude<R1, R>, E, A>
+>(2, <R1, R, E, A>(self: Effect.Effect<R1, E, A>, context: Context.Context<R>) =>
+  fiberRefLocallyWith(
+    currentContext,
+    (parent) => Context.merge(parent, context)
+  )(self as Effect.Effect<never, E, A>))
+
+/* @internal */
+export const mapInputContext = dual<
+  <R0, R>(
+    f: (context: Context.Context<R0>) => Context.Context<R>
+  ) => <E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R0, E, A>,
+  <R0, R, E, A>(
+    self: Effect.Effect<R, E, A>,
+    f: (context: Context.Context<R0>) => Context.Context<R>
+  ) => Effect.Effect<R0, E, A>
+>(2, <R0, R, E, A>(
+  self: Effect.Effect<R, E, A>,
+  f: (context: Context.Context<R0>) => Context.Context<R>
+) => contextWithEffect((context: Context.Context<R0>) => provideContext(self, f(context))))
+
+// -----------------------------------------------------------------------------
+// Tracing
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export const currentSpanFromFiber = <E, A>(fiber: Fiber.RuntimeFiber<E, A>): Option.Option<Tracer.Span> => {
+  const span = fiber.getFiberRef(currentContext).unsafeMap.get(internalTracer.spanTag) as Tracer.ParentSpan | undefined
+  return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
+}

package/src/internal/fiberRuntime.ts

@@ -45,7 +45,6 @@ import { OpSupervision } from "../internal/runtimeFlags"
 import * as supervisor from "../internal/supervisor"
 import * as SupervisorPatch from "../internal/supervisor/patch"
 import * as tracer from "../internal/tracer"
-import * as List from "../List"
 import type { Logger } from "../Logger"
 import * as LogLevel from "../LogLevel"
 import type * as MetricLabel from "../MetricLabel"
@@ -1374,7 +1373,7 @@ export const tracerLogger = internalLogger.makeLogger<unknown, void>(({
   logLevel,
   message
 }) => {
-  const span = Option.flatMap(fiberRefs.get(context, core.currentTracerSpan), List.head)
+  const span = Option.flatMap(fiberRefs.get(context, core.currentContext), Context.getOption(tracer.spanTag))
   const clockService = Option.map(
     fiberRefs.get(context, defaultServices.currentServices),
     (_) => Context.get(_, clock.clockTag)
@@ -3437,7 +3436,6 @@ export const makeSpanScoped = (
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
   }
 ): Effect.Effect<Scope.Scope, never, Tracer.Span> =>
@@ -3450,31 +3448,10 @@ export const makeSpanScoped = (
       )
   )
 
-/* @internal */
-export const setSpan = (
-  name: string,
-  options?: {
-    readonly attributes?: Record<string, unknown>
-    readonly links?: ReadonlyArray<Tracer.SpanLink>
-    readonly parent?: Tracer.ParentSpan
-    readonly root?: boolean
-    readonly sampled?: boolean
-    readonly context?: Context.Context<never>
-  }
-): Effect.Effect<Scope.Scope, never, void> =>
-  core.tap(
-    makeSpanScoped(name, options),
-    (span) => setParentSpan(span)
-  )
-
 /* @internal */
 export const withTracerScoped = (value: Tracer.Tracer): Effect.Effect<Scope.Scope, never, void> =>
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(tracer.tracerTag, value))
 
-/* @internal */
-export const setParentSpan = (span: Tracer.ParentSpan): Effect.Effect<Scope.Scope, never, void> =>
-  fiberRefLocallyScopedWith(core.currentTracerSpan, List.prepend(span))
-
 /** @internal */
 export const withSpanScoped = dual<
   (name: string, options?: {
@@ -3482,22 +3459,20 @@ export const withSpanScoped = dual<
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
-  }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | Scope.Scope, E, A>,
+  }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<Exclude<R, Tracer.ParentSpan> | Scope.Scope, E, A>,
   <R, E, A>(self: Effect.Effect<R, E, A>, name: string, options?: {
     readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
-  }) => Effect.Effect<R | Scope.Scope, E, A>
+  }) => Effect.Effect<Exclude<R, Tracer.ParentSpan> | Scope.Scope, E, A>
 >(
   (args) => typeof args[0] !== "string",
   (self, name, options) =>
     core.flatMap(
       makeSpanScoped(name, options),
-      (span) => core.fiberRefLocallyWith(self, core.currentTracerSpan, List.prepend(span))
+      (span) => internalEffect.provideService(self, tracer.spanTag, span)
     )
 )

package/src/internal/layer/circular.ts

@@ -1,5 +1,5 @@
 import type * as ConfigProvider from "../../ConfigProvider"
-import type * as Context from "../../Context"
+import * as Context from "../../Context"
 import type * as Effect from "../../Effect"
 import type * as Exit from "../../Exit"
 import { dual } from "../../Function"
@@ -16,6 +16,7 @@ import type * as LogLevel from "../../LogLevel"
 import type { Scope } from "../../Scope"
 import type * as Supervisor from "../../Supervisor"
 import type * as Tracer from "../../Tracer"
+import * as tracer from "../tracer"
 
 // circular with Logger
 
@@ -184,33 +185,29 @@ export const setConfigProvider = (configProvider: ConfigProvider.ConfigProvider)
   layer.scopedDiscard(fiberRuntime.withConfigProviderScoped(configProvider))
 
 /** @internal */
-export const setParentSpan = (span: Tracer.ParentSpan): Layer.Layer<never, never, never> =>
-  layer.scopedDiscard(fiberRuntime.setParentSpan(span))
+export const parentSpan = (span: Tracer.ParentSpan): Layer.Layer<never, never, Tracer.ParentSpan> =>
+  layer.succeedContext(Context.make(tracer.spanTag, span))
 
 /** @internal */
-export const setSpan = (
+export const span = (
   name: string,
   options?: {
     readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
     readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
   }
-): Layer.Layer<never, never, never> =>
-  layer.scopedDiscard(
+): Layer.Layer<never, never, Tracer.ParentSpan> =>
+  layer.scoped(
+    tracer.spanTag,
     options?.onEnd
       ? core.tap(
         fiberRuntime.makeSpanScoped(name, options),
-        (span) =>
-          core.zipRight(
-            fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit)),
-            fiberRuntime.setParentSpan(span)
-          )
+        (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
       )
-      : fiberRuntime.setSpan(name, options)
+      : fiberRuntime.makeSpanScoped(name, options)
   )
 
 /** @internal */

package/src/internal/layer.ts

@@ -18,7 +18,6 @@ import * as ref from "../internal/ref"
 import * as runtime from "../internal/runtime"
 import * as synchronized from "../internal/synchronizedRef"
 import type * as Layer from "../Layer"
-import * as List from "../List"
 import { pipeArguments } from "../Pipeable"
 import type * as Runtime from "../Runtime"
 import type * as Schedule from "../Schedule"
@@ -28,6 +27,7 @@ import * as Scope from "../Scope"
 import type * as Synchronized from "../SynchronizedRef"
 import type * as Tracer from "../Tracer"
 import * as runtimeFlags from "./runtimeFlags"
+import * as tracer from "./tracer"
 
 /** @internal */
 const LayerSymbolKey = "effect/Layer"
@@ -1127,19 +1127,17 @@ export const withSpan = dual<
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
     readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
-  }) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<R, E, A>,
+  }) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>,
   <R, E, A>(self: Layer.Layer<R, E, A>, name: string, options?: {
     readonly attributes?: Record<string, unknown>
     readonly links?: ReadonlyArray<Tracer.SpanLink>
     readonly parent?: Tracer.ParentSpan
     readonly root?: boolean
-    readonly sampled?: boolean
     readonly context?: Context.Context<never>
     readonly onEnd?: (span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
-  }) => Layer.Layer<R, E, A>
+  }) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>
 >((args) => isLayer(args[0]), (self, name, options) =>
   unwrapScoped(
     core.map(
@@ -1155,9 +1153,11 @@ export const withSpan = dual<
 
 /** @internal */
 export const withParentSpan = dual<
-  (span: Tracer.ParentSpan) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<R, E, A>,
-  <R, E, A>(self: Layer.Layer<R, E, A>, span: Tracer.ParentSpan) => Layer.Layer<R, E, A>
->(2, (self, span) => fiberRefLocallyWith(self, core.currentTracerSpan, List.prepend(span)))
+  (
+    span: Tracer.ParentSpan
+  ) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>,
+  <R, E, A>(self: Layer.Layer<R, E, A>, span: Tracer.ParentSpan) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>
+>(2, (self, span) => provide(succeedContext(Context.make(tracer.spanTag, span)), self))
 
 // circular with Effect
 

package/src/internal/stream.ts

@@ -6850,10 +6850,9 @@ export const withSpan = dual<
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
-  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<R, E, A>,
+  ) => <R, E, A>(self: Stream.Stream<R, E, A>) => Stream.Stream<Exclude<R, Tracer.ParentSpan>, E, A>,
   <R, E, A>(
     self: Stream.Stream<R, E, A>,
     name: string,
@@ -6862,11 +6861,10 @@ export const withSpan = dual<
       readonly links?: ReadonlyArray<Tracer.SpanLink>
       readonly parent?: Tracer.ParentSpan
       readonly root?: boolean
-      readonly sampled?: boolean
       readonly context?: Context.Context<never>
     }
-  ) => Stream.Stream<R, E, A>
->(3, (self, name, options) => unwrapScoped(Effect.as(Effect.setSpan(name, options), self)))
+  ) => Stream.Stream<Exclude<R, Tracer.ParentSpan>, E, A>
+>(3, (self, name, options) => new StreamImpl(channel.withSpan(toChannel(self), name, options)))
 
 /** @internal */
 export const zip = dual<