effect 2.0.0-next.46 → 2.0.0-next.48

package/src/Predicate.ts

@@ -110,16 +110,16 @@ export const isBoolean = (input: unknown): input is boolean => typeof input ===
  * @param input - The value to test.
  *
  * @example
- * import { isBigint } from "effect/Predicate"
+ * import { isBigInt } from "effect/Predicate"
  *
- * assert.deepStrictEqual(isBigint(1n), true)
+ * assert.deepStrictEqual(isBigInt(1n), true)
  *
- * assert.deepStrictEqual(isBigint(1), false)
+ * assert.deepStrictEqual(isBigInt(1), false)
  *
  * @category guards
  * @since 2.0.0
  */
-export const isBigint = (input: unknown): input is bigint => typeof input === "bigint"
+export const isBigInt = (input: unknown): input is bigint => typeof input === "bigint"
 
 /**
  * Tests if a value is a `symbol`.

package/src/Queue.ts

@@ -216,6 +216,14 @@ export interface Strategy<A> extends Queue.StrategyVariance<A> {
     isShutdown: MutableRef.MutableRef<boolean>
   ): Effect.Effect<never, never, boolean>
 
+  /**
+   * It is called when the backing queue is empty but there are some
+   * takers that can be completed
+   */
+  onCompleteTakersWithEmptyQueue(
+    takers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
+  ): void
+
   /**
    * Determines the behavior of the `Queue.Strategy` when the `Queue` has empty
    * slots following a `take` operation.

package/src/Stream.ts

@@ -4000,10 +4000,11 @@ export const withSpan: {
   (
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      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>
     }
   ): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
@@ -4011,10 +4012,11 @@ export const withSpan: {
     self: Stream<R, E, A>,
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      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>
     }
   ): Stream<R, E, A>

package/src/Tracer.ts

@@ -29,6 +29,7 @@ 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
@@ -62,6 +63,7 @@ export interface ExternalSpan {
   readonly _tag: "ExternalSpan"
   readonly spanId: string
   readonly traceId: string
+  readonly sampled: boolean
   readonly context: Context.Context<never>
 }
 
@@ -77,17 +79,13 @@ export interface Span {
   readonly parent: Option.Option<ParentSpan>
   readonly context: Context.Context<never>
   readonly status: SpanStatus
-  readonly attributes: ReadonlyMap<string, AttributeValue>
+  readonly attributes: ReadonlyMap<string, unknown>
   readonly links: ReadonlyArray<SpanLink>
+  readonly sampled: boolean
   readonly end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void
-  readonly attribute: (key: string, value: AttributeValue) => void
-  readonly event: (name: string, startTime: bigint, attributes?: Record<string, AttributeValue>) => void
+  readonly attribute: (key: string, value: unknown) => void
+  readonly event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void
 }
-/**
- * @since 2.0.0
- * @category models
- */
-export type AttributeValue = string | boolean | number
 
 /**
  * @since 2.0.0
@@ -96,7 +94,7 @@ export type AttributeValue = string | boolean | number
 export interface SpanLink {
   readonly _tag: "SpanLink"
   readonly span: ParentSpan
-  readonly attributes: Readonly<Record<string, AttributeValue>>
+  readonly attributes: Readonly<Record<string, unknown>>
 }
 
 /**
@@ -111,6 +109,17 @@ export const Tracer: Context.Tag<Tracer, Tracer> = internal.tracerTag
  */
 export const make: (options: Omit<Tracer, typeof TracerTypeId>) => Tracer = internal.make
 
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const externalSpan: (options: {
+  readonly spanId: string
+  readonly traceId: string
+  readonly sampled?: boolean | undefined
+  readonly context?: Context.Context<never> | undefined
+}) => ExternalSpan = internal.externalSpan
+
 /**
  * @since 2.0.0
  * @category constructors

package/src/index.ts

@@ -36,7 +36,7 @@ export {
  *
  * @since 2.0.0
  */
-export * as Bigint from "effect/Bigint"
+export * as BigInt from "effect/BigInt"
 
 /**
  * This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
@@ -388,6 +388,11 @@ export * as LogSpan from "effect/LogSpan"
  */
 export * as Logger from "effect/Logger"
 
+/**
+ * @since 1.0.0
+ */
+export * as Match from "effect/Match"
+
 /**
  * @since 2.0.0
  */

package/src/internal/channel.ts

@@ -2302,10 +2302,11 @@ export const withSpan = dual<
   (
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      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>
     }
   ) => <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
@@ -2315,14 +2316,15 @@ export const withSpan = dual<
     self: Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>,
     name: string,
     options?: {
-      readonly attributes?: Record<string, Tracer.AttributeValue>
+      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>
     }
   ) => Channel.Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>
->(3, (self, name, options) => unwrapScoped(Effect.as(Effect.withSpanScoped(name, options), self)))
+>(3, (self, name, options) => unwrapScoped(Effect.as(Effect.setSpan(name, options), self)))
 
 /** @internal */
 export const writeAll = <OutElem>(

package/src/internal/core-effect.ts

@@ -22,7 +22,6 @@ import * as metricLabel from "../internal/metric/label"
 import * as runtimeFlags from "../internal/runtimeFlags"
 import * as SingleShotGen from "../internal/singleShotGen"
 import * as List from "../List"
-import type * as Logger from "../Logger"
 import * as LogLevel from "../LogLevel"
 import * as LogSpan from "../LogSpan"
 import type * as Metric from "../Metric"
@@ -38,14 +37,14 @@ import * as Tracer from "../Tracer"
 /* @internal */
 export const annotateLogs = dual<
   {
-    (key: string, value: Logger.AnnotationValue): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+    (key: string, value: unknown): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
     (
-      values: Record<string, Logger.AnnotationValue>
+      values: Record<string, unknown>
     ): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
   },
   {
-    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: Logger.AnnotationValue): Effect.Effect<R, E, A>
-    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, Logger.AnnotationValue>): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: unknown): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, unknown>): Effect.Effect<R, E, A>
   }
 >(
   (args) => core.isEffect(args[0]),
@@ -57,7 +56,7 @@ export const annotateLogs = dual<
       typeof args[1] === "string"
         ? HashMap.set(args[1], args[2])
         : (annotations) =>
-          Object.entries(args[1] as Record<string, Logger.AnnotationValue>).reduce(
+          Object.entries(args[1] as Record<string, unknown>).reduce(
             (acc, [key, value]) => HashMap.set(acc, key, value),
             annotations
           )
@@ -942,7 +941,7 @@ export const withLogSpan = dual<
     )))
 
 /* @internal */
-export const logAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, Logger.AnnotationValue>> = core
+export const logAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, unknown>> = core
   .fiberRefGet(
     core.currentLogAnnotations
   )
@@ -1897,8 +1896,8 @@ export const serviceMembers = <I, S>(tag: Context.Tag<I, S>): {
 
 /* @internal */
 export const annotateCurrentSpan: {
-  (key: string, value: Tracer.AttributeValue): Effect.Effect<never, never, void>
-  (values: Record<string, Tracer.AttributeValue>): Effect.Effect<never, never, void>
+  (key: string, value: unknown): Effect.Effect<never, never, void>
+  (values: Record<string, unknown>): Effect.Effect<never, never, void>
 } = function(): Effect.Effect<never, never, void> {
   const args = arguments
   return core.flatMap(
@@ -1921,14 +1920,14 @@ export const annotateCurrentSpan: {
 /* @internal */
 export const annotateSpans = dual<
   {
-    (key: string, value: Tracer.AttributeValue): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+    (key: string, value: unknown): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
     (
-      values: Record<string, Tracer.AttributeValue>
+      values: Record<string, unknown>
     ): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
   },
   {
-    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: Tracer.AttributeValue): Effect.Effect<R, E, A>
-    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, Tracer.AttributeValue>): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, key: string, value: unknown): Effect.Effect<R, E, A>
+    <R, E, A>(effect: Effect.Effect<R, E, A>, values: Record<string, unknown>): Effect.Effect<R, E, A>
   }
 >(
   (args) => core.isEffect(args[0]),
@@ -1940,7 +1939,7 @@ export const annotateSpans = dual<
       typeof args[1] === "string"
         ? HashMap.set(args[1], args[2])
         : (annotations) =>
-          Object.entries(args[1] as Record<string, Tracer.AttributeValue>).reduce(
+          Object.entries(args[1] as Record<string, unknown>).reduce(
             (acc, [key, value]) => HashMap.set(acc, key, value),
             annotations
           )
@@ -1971,12 +1970,12 @@ export const currentTimeNanosTracing = core.fiberRefGetWith(
 export const linkSpans = dual<
   (
     span: Tracer.ParentSpan,
-    attributes?: Record<string, Tracer.AttributeValue>
+    attributes?: Record<string, unknown>
   ) => <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,
-    attributes?: Record<string, Tracer.AttributeValue>
+    attributes?: Record<string, unknown>
   ) => Effect.Effect<R, E, A>
 >(
   (args) => core.isEffect(args[0]),
@@ -1998,10 +1997,11 @@ export const linkSpans = dual<
 export const makeSpan = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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>
   }
 ) =>
@@ -2031,6 +2031,7 @@ 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))
@@ -2044,7 +2045,7 @@ export const makeSpan = (
   )
 
 /* @internal */
-export const spanAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, Tracer.AttributeValue>> = core
+export const spanAnnotations: Effect.Effect<never, never, HashMap.HashMap<string, unknown>> = core
   .fiberRefGet(core.currentTracerSpanAnnotations)
 
 /* @internal */
@@ -2055,10 +2056,11 @@ export const spanLinks: Effect.Effect<never, never, Chunk.Chunk<Tracer.SpanLink>
 export const useSpan: {
   <R, E, A>(name: string, evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
   <R, E, A>(name: string, options: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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>
   }, evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
 } = <R, E, A>(
@@ -2069,10 +2071,11 @@ export const useSpan: {
   ]
 ) => {
   const options: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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>
   } | undefined = args.length === 1 ? undefined : args[0]
   const evaluate: (span: Tracer.Span) => Effect.Effect<R, E, A> = args[args.length - 1]
@@ -2102,17 +2105,19 @@ export const withParentSpan = dual<
 /** @internal */
 export const withSpan = dual<
   (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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>
   }) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
   <R, E, A>(self: Effect.Effect<R, E, A>, name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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>
 >(

package/src/internal/core.ts

@@ -28,7 +28,6 @@ import * as DeferredOpCodes from "../internal/opCodes/deferred"
 import * as OpCodes from "../internal/opCodes/effect"
 import * as _runtimeFlags from "../internal/runtimeFlags"
 import * as List from "../List"
-import type * as Logger from "../Logger"
 import type * as LogLevel from "../LogLevel"
 import type * as LogSpan from "../LogSpan"
 import type * as MetricLabel from "../MetricLabel"
@@ -1846,7 +1845,7 @@ export const currentMaxOpsBeforeYield: FiberRef.FiberRef<number> = globalValue(
 )
 
 /** @internal */
-export const currentLogAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, Logger.AnnotationValue>> = globalValue(
+export const currentLogAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, unknown>> = globalValue(
   Symbol.for("effect/FiberRef/currentLogAnnotation"),
   () => fiberRefUnsafeMake(HashMap.empty())
 )
@@ -1945,11 +1944,10 @@ export const currentTracerTimingEnabled: FiberRef.FiberRef<boolean> = globalValu
 )
 
 /** @internal */
-export const currentTracerSpanAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, Tracer.AttributeValue>> =
-  globalValue(
-    Symbol.for("effect/FiberRef/currentTracerSpanAnnotations"),
-    () => fiberRefUnsafeMake(HashMap.empty())
-  )
+export const currentTracerSpanAnnotations: FiberRef.FiberRef<HashMap.HashMap<string, unknown>> = globalValue(
+  Symbol.for("effect/FiberRef/currentTracerSpanAnnotations"),
+  () => fiberRefUnsafeMake(HashMap.empty())
+)
 
 /** @internal */
 export const currentTracerSpanLinks: FiberRef.FiberRef<Chunk.Chunk<Tracer.SpanLink>> = globalValue(

package/src/internal/fiberRuntime.ts

@@ -17,6 +17,7 @@ import * as FiberRefsPatch from "../FiberRefsPatch"
 import * as FiberStatus from "../FiberStatus"
 import type { LazyArg } from "../Function"
 import { dual, identity, pipe } from "../Function"
+import * as HashMap from "../HashMap"
 import * as HashSet from "../HashSet"
 import * as _RequestBlock from "../internal/blockedRequests"
 import * as internalCause from "../internal/cause"
@@ -1382,7 +1383,7 @@ export const tracerLogger = internalLogger.makeLogger<unknown, void>(({
     return
   }
 
-  const attributes = Object.fromEntries(annotations)
+  const attributes = Object.fromEntries(HashMap.map(annotations, (value) => internalLogger.serializeUnknown(value)))
   attributes["effect.fiberId"] = FiberId.threadName(fiberId)
   attributes["effect.logLevel"] = logLevel.label
 
@@ -3429,13 +3430,14 @@ export const interruptWhenPossible = dual<
 // circular Tracer
 
 /** @internal */
-export const useSpanScoped = (
+export const makeSpanScoped = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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, Tracer.Span> =>
@@ -3449,23 +3451,20 @@ export const useSpanScoped = (
   )
 
 /* @internal */
-export const withSpanScoped = (
+export const setSpan = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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.flatMap(
-    useSpanScoped(name, options),
-    (span) =>
-      fiberRefLocallyScopedWith(
-        core.currentTracerSpan,
-        List.prepend(span)
-      )
+  core.tap(
+    makeSpanScoped(name, options),
+    (span) => setParentSpan(span)
   )
 
 /* @internal */
@@ -3473,5 +3472,32 @@ export const withTracerScoped = (value: Tracer.Tracer): Effect.Effect<Scope.Scop
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(tracer.tracerTag, value))
 
 /* @internal */
-export const withParentSpanScoped = (span: Tracer.ParentSpan): Effect.Effect<Scope.Scope, never, void> =>
+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?: {
+    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>
+  }) => <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>, 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>
+>(
+  (args) => typeof args[0] !== "string",
+  (self, name, options) =>
+    core.flatMap(
+      makeSpanScoped(name, options),
+      (span) => core.fiberRefLocallyWith(self, core.currentTracerSpan, List.prepend(span))
+    )
+)

package/src/internal/layer/circular.ts

@@ -1,6 +1,7 @@
 import type * as ConfigProvider from "../../ConfigProvider"
 import type * as Context from "../../Context"
 import type * as Effect from "../../Effect"
+import type * as Exit from "../../Exit"
 import { dual } from "../../Function"
 import * as HashSet from "../../HashSet"
 import * as core from "../../internal/core"
@@ -9,7 +10,7 @@ import * as layer from "../../internal/layer"
 import * as runtimeFlags from "../../internal/runtimeFlags"
 import * as runtimeFlagsPatch from "../../internal/runtimeFlagsPatch"
 import * as _supervisor from "../../internal/supervisor"
-import * as Layer from "../../Layer"
+import type * as Layer from "../../Layer"
 import type * as Logger from "../../Logger"
 import type * as LogLevel from "../../LogLevel"
 import type { Scope } from "../../Scope"
@@ -50,7 +51,7 @@ export const addLogger = <A>(logger: Logger.Logger<unknown, A>): Layer.Layer<nev
 export const addLoggerEffect = <R, E, A>(
   effect: Effect.Effect<R, E, Logger.Logger<unknown, A>>
 ): Layer.Layer<R, E, never> =>
-  Layer.unwrapEffect(
+  layer.unwrapEffect(
     core.map(effect, addLogger)
   )
 
@@ -58,7 +59,7 @@ export const addLoggerEffect = <R, E, A>(
 export const addLoggerScoped = <R, E, A>(
   effect: Effect.Effect<R, E, Logger.Logger<unknown, A>>
 ): Layer.Layer<Exclude<R, Scope>, E, never> =>
-  Layer.unwrapScoped(
+  layer.unwrapScoped(
     core.map(effect, addLogger)
   )
 
@@ -184,19 +185,33 @@ export const setConfigProvider = (configProvider: ConfigProvider.ConfigProvider)
 
 /** @internal */
 export const setParentSpan = (span: Tracer.ParentSpan): Layer.Layer<never, never, never> =>
-  layer.scopedDiscard(fiberRuntime.withParentSpanScoped(span))
+  layer.scopedDiscard(fiberRuntime.setParentSpan(span))
 
 /** @internal */
 export const setSpan = (
   name: string,
   options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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(fiberRuntime.withSpanScoped(name, options))
+): Layer.Layer<never, never, never> =>
+  layer.scopedDiscard(
+    options?.onEnd
+      ? core.tap(
+        fiberRuntime.makeSpanScoped(name, options),
+        (span) =>
+          core.zipRight(
+            fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit)),
+            fiberRuntime.setParentSpan(span)
+          )
+      )
+      : fiberRuntime.setSpan(name, options)
+  )
 
 /** @internal */
 export const setTracer = (tracer: Tracer.Tracer): Layer.Layer<never, never, never> =>

package/src/internal/layer.ts

@@ -18,6 +18,7 @@ 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"
@@ -1122,27 +1123,42 @@ export const unwrapScoped = <R, E, R1, E1, A>(
 /** @internal */
 export const withSpan = dual<
   (name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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>
   }) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<R, E, A>,
   <R, E, A>(self: Layer.Layer<R, E, A>, name: string, options?: {
-    readonly attributes?: Record<string, Tracer.AttributeValue>
+    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>
 >((args) => isLayer(args[0]), (self, name, options) =>
   unwrapScoped(
     core.map(
-      fiberRuntime.useSpanScoped(name, options),
-      (span) => locallyEffect(self, effect.withParentSpan(span))
+      options?.onEnd
+        ? core.tap(
+          fiberRuntime.makeSpanScoped(name, options),
+          (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
+        )
+        : fiberRuntime.makeSpanScoped(name, options),
+      (span) => withParentSpan(self, span)
     )
   ))
 
+/** @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)))
+
 // circular with Effect
 
 const provideSomeLayer = dual<

package/src/internal/logger.ts

@@ -37,7 +37,7 @@ export const makeLogger = <Message, Output>(
       readonly cause: CauseExt.Cause<unknown>
       readonly context: FiberRefs.FiberRefs
       readonly spans: List.List<LogSpan.LogSpan>
-      readonly annotations: HashMap.HashMap<string, Logger.AnnotationValue>
+      readonly annotations: HashMap.HashMap<string, unknown>
       readonly date: Date
     }
   ) => Output
@@ -207,7 +207,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
         }
         output = output + filterKeyName(key)
         output = output + "="
-        output = appendQuoted(String(value), output)
+        output = appendQuoted(serializeUnknown(value), output)
       }
     }
 
@@ -215,7 +215,7 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
   }
 )
 
-const serializeUnknown = (u: unknown): string => {
+export const serializeUnknown = (u: unknown): string => {
   try {
     return typeof u === "object" ? JSON.stringify(u) : String(u)
   } catch (_) {
@@ -282,7 +282,7 @@ export const logfmtLogger = makeLogger<unknown, string>(
         }
         output = output + filterKeyName(key)
         output = output + "="
-        output = appendQuotedLogfmt(String(value), output)
+        output = appendQuotedLogfmt(serializeUnknown(value), output)
       }
     }