effect 2.4.14 → 2.4.16

package/src/internal/config.ts

@@ -1,6 +1,7 @@
 import * as Chunk from "../Chunk.js"
 import type * as Config from "../Config.js"
 import * as ConfigError from "../ConfigError.js"
+import * as Duration from "../Duration.js"
 import * as Either from "../Either.js"
 import type { LazyArg } from "../Function.js"
 import { constTrue, dual, pipe } from "../Function.js"
@@ -288,6 +289,15 @@ export const logLevel = (name?: string): Config.Config<LogLevel.LogLevel> => {
   return name === undefined ? config : nested(config, name)
 }
 
+/** @internal */
+export const duration = (name?: string): Config.Config<Duration.Duration> => {
+  const config = mapOrFail(string(), (value) => {
+    const duration = Duration.decodeUnknown(value)
+    return Either.fromOption(duration, () => configError.InvalidData([], `Expected a duration but received ${value}`))
+  })
+  return name === undefined ? config : nested(config, name)
+}
+
 /** @internal */
 export const map = dual<
   <A, B>(f: (a: A) => B) => (self: Config.Config<A>) => Config.Config<B>,

package/src/internal/fiberRuntime.ts

@@ -779,7 +779,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
     if (exit._tag === "Failure") {
       const level = this.getFiberRef(core.currentUnhandledErrorLogLevel)
       if (!internalCause.isInterruptedOnly(exit.cause) && level._tag === "Some") {
-        this.log("Fiber terminated with a non handled error", exit.cause, level)
+        this.log("Fiber terminated with an unhandled error", exit.cause, level)
       }
     }
   }
@@ -2028,7 +2028,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
           }
           return exits
         }
-        const runFiber = <A, E, R>(eff: Effect.Effect<A, E, R>) => {
+        const runFiber = <A, E, R>(eff: Effect.Effect<A, E, R>, interruptImmediately = false) => {
           const runnable = core.uninterruptible(graft(eff))
           const fiber = unsafeForkUnstarted(
             runnable,
@@ -2037,6 +2037,9 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
             fiberScope.globalScope
           )
           parent._scheduler.scheduleTask(() => {
+            if (interruptImmediately) {
+              fiber.unsafeInterruptAsFork(parent.id())
+            }
             fiber.resume(runnable)
           }, 0)
           return fiber
@@ -2142,26 +2145,44 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
             }
           })
         )
-        return core.asUnit(core.tap(
-          core.flatten(core.onInterrupt(
-            restore(internalFiber.join(processingFiber)),
-            () => {
-              onInterruptSignal()
-              const all = [processingFiber] as Array<FiberRuntime<any, any>>
-              residual.map((blocked) => {
-                const fiber = runFiber(blocked)
-                parent._scheduler.scheduleTask(() => {
-                  fiber.unsafeInterruptAsFork(parent.id())
-                }, 0)
-                return fiber
-              }).forEach((additional) => {
-                all.push(additional as unknown as FiberRuntime<any, any>)
-              })
-              return core.exit(fiberJoinAll(all))
-            }
-          )),
-          () => core.forEachSequential(joinOrder, (f) => f.inheritAll)
-        ))
+        return core.asUnit(
+          core.onExit(
+            core.flatten(restore(internalFiber.join(processingFiber))),
+            core.exitMatch({
+              onFailure: () => {
+                onInterruptSignal()
+                const target = residual.length + 1
+                const concurrency = Math.min(typeof n === "number" ? n : residual.length, residual.length)
+                const toPop = Array.from(residual)
+                return core.async<any, any>((cb) => {
+                  const exits: Array<Exit.Exit<any, any>> = []
+                  let count = 0
+                  let index = 0
+                  const check = (index: number, hitNext: boolean) => (exit: Exit.Exit<any, any>) => {
+                    exits[index] = exit
+                    count++
+                    if (count === target) {
+                      cb(Option.getOrThrow(core.exitCollectAll(exits, { parallel: true })))
+                    }
+                    if (toPop.length > 0 && hitNext) {
+                      next()
+                    }
+                  }
+                  const next = () => {
+                    runFiber(toPop.pop()!, true).addObserver(check(index, true))
+                    index++
+                  }
+                  processingFiber.addObserver(check(index, false))
+                  index++
+                  for (let i = 0; i < concurrency; i++) {
+                    next()
+                  }
+                }) as any
+              },
+              onSuccess: () => core.forEachSequential(joinOrder, (f) => f.inheritAll)
+            })
+          )
+        )
       })
     )
   )

package/src/internal/tracer.ts

@@ -21,8 +21,8 @@ export const tracerTag = Context.GenericTag<Tracer.Tracer>("effect/Tracer")
 /** @internal */
 export const spanTag = Context.GenericTag<Tracer.ParentSpan>("effect/ParentSpan")
 
-const randomString = (function() {
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+const randomHexString = (function() {
+  const characters = "abcdef0123456789"
   const charactersLength = characters.length
   return function(length: number) {
     let result = ""
@@ -56,7 +56,8 @@ export class NativeSpan implements Tracer.Span {
       startTime
     }
     this.attributes = new Map()
-    this.spanId = `span${randomString(16)}`
+    this.traceId = parent._tag === "Some" ? parent.value.traceId : randomHexString(32)
+    this.spanId = randomHexString(16)
   }
 
   end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void {

package/src/internal/version.ts

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