effect 3.1.5 → 3.2.0

package/src/internal/fiberRuntime.ts

@@ -1335,7 +1335,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
             internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none))
           )
         } else {
-          cur = core.exitFailCause(internalCause.die(e))
+          cur = core.die(e)
         }
       }
     }
@@ -3622,8 +3622,9 @@ export const interruptWhenPossible = dual<
 export const makeSpanScoped = (
   name: string,
   options?: Tracer.SpanOptions | undefined
-): Effect.Effect<Tracer.Span, never, Scope.Scope> =>
-  core.uninterruptible(
+): Effect.Effect<Tracer.Span, never, Scope.Scope> => {
+  options = tracer.addSpanStackTrace(options)
+  return core.uninterruptible(
     core.withFiberRuntime((fiber) => {
       const scope = Context.unsafeGet(fiber.getFiberRef(core.currentContext), scopeTag)
       const span = internalEffect.unsafeMakeSpan(fiber, name, options)
@@ -3641,27 +3642,37 @@ export const makeSpanScoped = (
       )
     })
   )
+}
 
 /* @internal */
 export const withTracerScoped = (value: Tracer.Tracer): Effect.Effect<void, never, Scope.Scope> =>
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(tracer.tracerTag, value))
 
 /** @internal */
-export const withSpanScoped = dual<
+export const withSpanScoped: {
   (
     name: string,
     options?: Tracer.SpanOptions
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>,
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Scope.Scope | Exclude<R, Tracer.ParentSpan>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
     name: string,
     options?: Tracer.SpanOptions
-  ) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>
->(
-  (args) => typeof args[0] !== "string",
-  (self, name, options) =>
+  ): Effect.Effect<A, E, Scope.Scope | Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return core.flatMap(
+      makeSpanScoped(name, tracer.addSpanStackTrace(options)),
+      (span) => internalEffect.provideService(self, tracer.spanTag, span)
+    )
+  }
+  return (self: Effect.Effect<any, any, any>) =>
     core.flatMap(
-      makeSpanScoped(name, options),
+      makeSpanScoped(name, tracer.addSpanStackTrace(options)),
       (span) => internalEffect.provideService(self, tracer.spanTag, span)
     )
-)
+} as any

package/src/internal/layer/circular.ts

@@ -196,8 +196,9 @@ export const span = (
       | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
       | undefined
   }
-): Layer.Layer<Tracer.ParentSpan> =>
-  layer.scoped(
+): Layer.Layer<Tracer.ParentSpan> => {
+  options = tracer.addSpanStackTrace(options) as any
+  return layer.scoped(
     tracer.spanTag,
     options?.onEnd
       ? core.tap(
@@ -206,6 +207,7 @@ export const span = (
       )
       : fiberRuntime.makeSpanScoped(name, options)
   )
+}
 
 /** @internal */
 export const setTracer = (tracer: Tracer.Tracer): Layer.Layer<never> =>

package/src/internal/layer.ts

@@ -1113,7 +1113,7 @@ export const unwrapScoped = <A, E1, R1, E, R>(
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const withSpan = dual<
+export const withSpan: {
   (
     name: string,
     options?: Tracer.SpanOptions & {
@@ -1121,7 +1121,7 @@ export const withSpan = dual<
         | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
         | undefined
     }
-  ) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>,
+  ): <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
   <A, E, R>(
     self: Layer.Layer<A, E, R>,
     name: string,
@@ -1130,19 +1130,42 @@ export const withSpan = dual<
         | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
         | undefined
     }
-  ) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
->((args) => isLayer(args[0]), (self, name, options) =>
-  unwrapScoped(
-    core.map(
-      options?.onEnd
-        ? core.tap(
-          fiberRuntime.makeSpanScoped(name, options),
-          (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
-        )
-        : fiberRuntime.makeSpanScoped(name, options),
-      (span) => withParentSpan(self, span)
+  ): Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]) as Tracer.SpanOptions & {
+    readonly onEnd?:
+      | ((span: Tracer.Span, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>)
+      | undefined
+  }
+  if (dataFirst) {
+    const self = arguments[0]
+    return unwrapScoped(
+      core.map(
+        options?.onEnd
+          ? core.tap(
+            fiberRuntime.makeSpanScoped(name, options),
+            (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
+          )
+          : fiberRuntime.makeSpanScoped(name, options),
+        (span) => withParentSpan(self, span)
+      )
     )
-  ))
+  }
+  return (self: Layer.Layer<any, any, any>) =>
+    unwrapScoped(
+      core.map(
+        options?.onEnd
+          ? core.tap(
+            fiberRuntime.makeSpanScoped(name, options),
+            (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit))
+          )
+          : fiberRuntime.makeSpanScoped(name, options),
+        (span) => withParentSpan(self, span)
+      )
+    )
+} as any
 
 /** @internal */
 export const withParentSpan = dual<

package/src/internal/runtime.ts

@@ -173,12 +173,16 @@ class FiberFailureImpl extends Error implements Runtime.FiberFailure {
     const prettyErrors = InternalCause.prettyErrors(cause)
     if (prettyErrors.length > 0) {
       const head = prettyErrors[0]
-      this.name = head.message.split(":")[0]
-      this.message = head.message.substring(this.name.length + 2)
-      this.stack = InternalCause.pretty(cause)
+      this.name = head.name
+      this.message = head.message
+      this.stack = head.stack!
     }
 
     this.name = `(FiberFailure) ${this.name}`
+
+    if (this.message === undefined || this.message.length === 0) {
+      this.message = "An error has occurred"
+    }
   }
 
   toJSON(): unknown {
@@ -187,8 +191,9 @@ class FiberFailureImpl extends Error implements Runtime.FiberFailure {
       cause: this[FiberFailureCauseId].toJSON()
     }
   }
+
   toString(): string {
-    return "(FiberFailure) " + InternalCause.pretty(this[FiberFailureCauseId])
+    return "(FiberFailure) " + (this.stack ?? this.message)
   }
   [Inspectable.NodeInspectSymbol](): unknown {
     return this.toString()
@@ -290,7 +295,7 @@ export const unsafeRunPromiseExit = <R>(runtime: Runtime.Runtime<R>) =>
       } else {
         options.signal.addEventListener("abort", () => {
           fiber.unsafeInterruptAsFork(fiber.id())
-        })
+        }, { once: true })
       }
     }
   })

package/src/internal/schedule.ts

@@ -672,7 +672,7 @@ export const exponential = (
 ): Schedule.Schedule<Duration.Duration> => {
   const base = Duration.decode(baseInput)
   return delayedSchedule(
-    map(forever, (i) => Duration.times(base, Math.min(Number.MAX_SAFE_INTEGER, Math.pow(factor, i))))
+    map(forever, (i) => Duration.times(base, Math.pow(factor, i)))
   )
 }
 
@@ -1060,7 +1060,7 @@ export const modifyDelayEffect = dual<
           const oldStart = Intervals.start(intervals)
           const newStart = now + Duration.toMillis(duration)
           const delta = newStart - oldStart
-          const newEnd = Math.min(Math.max(0, Intervals.end(intervals) + delta), Number.MAX_SAFE_INTEGER)
+          const newEnd = Math.max(0, Intervals.end(intervals) + delta)
           const newInterval = Interval.make(newStart, newEnd)
           return [state, out, ScheduleDecision.continueWith(newInterval)] as const
         })

package/src/internal/stream.ts

@@ -50,6 +50,7 @@ import * as SinkEndReason from "./stream/sinkEndReason.js"
 import * as ZipAllState from "./stream/zipAllState.js"
 import * as ZipChunksState from "./stream/zipChunksState.js"
 import * as InternalTake from "./take.js"
+import * as InternalTracer from "./tracer.js"
 
 /** @internal */
 const StreamSymbolKey = "effect/Stream"
@@ -6541,16 +6542,30 @@ export const toQueueOfElements = dual<
   ))
 
 /** @internal */
-export const toReadableStream = <A, E>(source: Stream.Stream<A, E>) => {
-  let pull: Effect.Effect<void>
+export const toReadableStream = <A, E>(self: Stream.Stream<A, E>) =>
+  toReadableStreamRuntime(self, Runtime.defaultRuntime)
+
+/** @internal */
+export const toReadableStreamEffect = <A, E, R>(self: Stream.Stream<A, E, R>) =>
+  Effect.map(Effect.runtime<R>(), (runtime) => toReadableStreamRuntime(self, runtime))
+
+/** @internal */
+export const toReadableStreamRuntime = dual<
+  <XR>(runtime: Runtime.Runtime<XR>) => <A, E, R extends XR>(self: Stream.Stream<A, E, R>) => ReadableStream<A>,
+  <A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>) => ReadableStream<A>
+>(2, <A, E, XR, R extends XR>(self: Stream.Stream<A, E, R>, runtime: Runtime.Runtime<XR>): ReadableStream<A> => {
+  const runSync = Runtime.runSync(runtime)
+  const runPromise = Runtime.runPromise(runtime)
+
+  let pull: Effect.Effect<void, never, R>
   let scope: Scope.CloseableScope
   return new ReadableStream<A>({
     start(controller) {
-      scope = Effect.runSync(Scope.make())
+      scope = runSync(Scope.make())
       pull = pipe(
-        toPull(source),
-        Scope.use(scope),
-        Effect.runSync,
+        toPull(self),
+        Scope.extend(scope),
+        runSync,
         Effect.tap((chunk) =>
           Effect.sync(() => {
             Chunk.map(chunk, (a) => {
@@ -6573,13 +6588,13 @@ export const toReadableStream = <A, E>(source: Stream.Stream<A, E>) => {
       )
     },
     pull() {
-      return Effect.runPromise(pull)
+      return runPromise(pull)
     },
     cancel() {
-      return Effect.runPromise(Scope.close(scope, Exit.void))
+      return runPromise(Scope.close(scope, Exit.void))
     }
   })
-}
+})
 
 /** @internal */
 export const transduce = dual<
@@ -6801,17 +6816,26 @@ export const whenEffect = dual<
 )
 
 /** @internal */
-export const withSpan = dual<
+export const withSpan: {
   (
     name: string,
     options?: Tracer.SpanOptions
-  ) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, Exclude<R, Tracer.ParentSpan>>,
+  ): <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, Exclude<R, Tracer.ParentSpan>>
   <A, E, R>(
     self: Stream.Stream<A, E, R>,
     name: string,
     options?: Tracer.SpanOptions
-  ) => Stream.Stream<A, E, Exclude<R, Tracer.ParentSpan>>
->(3, (self, name, options) => new StreamImpl(channel.withSpan(toChannel(self), name, options)))
+  ): Stream.Stream<A, E, Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = InternalTracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return new StreamImpl(channel.withSpan(toChannel(self), name, options))
+  }
+  return (self: Stream.Stream<any, any, any>) => new StreamImpl(channel.withSpan(toChannel(self), name, options))
+} as any
 
 /** @internal */
 export const zip = dual<

package/src/internal/tracer.ts

@@ -106,3 +106,24 @@ export const externalSpan = (options: {
   sampled: options.sampled ?? true,
   context: options.context ?? Context.empty()
 })
+
+/** @internal */
+export const addSpanStackTrace = (options: Tracer.SpanOptions | undefined): Tracer.SpanOptions => {
+  if (options?.captureStackTrace === false) {
+    return options
+  } else if (options?.captureStackTrace !== undefined && typeof options.captureStackTrace !== "boolean") {
+    return options
+  }
+  const limit = Error.stackTraceLimit
+  Error.stackTraceLimit = 3
+  const traceError = new Error()
+  Error.stackTraceLimit = limit
+  if (traceError.stack === undefined) {
+    return { ...options, captureStackTrace: false }
+  }
+  const stack = traceError.stack.split("\n")
+  if (!stack[3]) {
+    return { ...options, captureStackTrace: false }
+  }
+  return { ...options, captureStackTrace: stack[3].trim() }
+}

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.1.5"
+let moduleVersion = "3.2.0"
 
 export const getCurrentVersion = () => moduleVersion