effect 3.20.0 → 3.21.0

package/src/RcMap.ts

@@ -56,6 +56,7 @@ export declare namespace RcMap {
  *
  * - `capacity`: The maximum number of resources that can be held in the map.
  * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration.
+ *   Can be a static duration or a function that returns a duration based on the key.
  *
  * @since 3.5.0
  * @category models
@@ -93,6 +94,7 @@ export const make: {
    *
    * - `capacity`: The maximum number of resources that can be held in the map.
    * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration.
+   *   Can be a static duration or a function that returns a duration based on the key.
    *
    * @since 3.5.0
    * @category models
@@ -121,7 +123,7 @@ export const make: {
   <K, A, E, R>(
    options: {
      readonly lookup: (key: K) => Effect.Effect<A, E, R>
-     readonly idleTimeToLive?: Duration.DurationInput | undefined
+     readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
      readonly capacity?: undefined
    }
   ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
@@ -136,6 +138,7 @@ export const make: {
    *
    * - `capacity`: The maximum number of resources that can be held in the map.
    * - `idleTimeToLive`: When the reference count reaches zero, the resource will be released after this duration.
+   *   Can be a static duration or a function that returns a duration based on the key.
    *
    * @since 3.5.0
    * @category models
@@ -164,7 +167,7 @@ export const make: {
   <K, A, E, R>(
    options: {
      readonly lookup: (key: K) => Effect.Effect<A, E, R>
-     readonly idleTimeToLive?: Duration.DurationInput | undefined
+     readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
      readonly capacity: number
    }
   ): Effect.Effect<RcMap<K, A, E | Cause.ExceededCapacityException>, never, Scope.Scope | R>

package/src/internal/cause.ts

@@ -14,7 +14,7 @@ import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import { hasProperty, isFunction } from "../Predicate.js"
 import type { AnySpan, Span } from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
+import type * as Types from "../Types.js"
 import { getBugErrorMessage } from "./errors.js"
 import * as OpCodes from "./opCodes/cause.js"
 
@@ -879,59 +879,58 @@ export const pretty = <E>(cause: Cause.Cause<E>, options?: {
     if (options?.renderErrorCause !== true || e.cause === undefined) {
       return e.stack
     }
-    return `${e.stack} {\n${renderErrorCause(e.cause as PrettyError, "  ")}\n}`
+    return `${e.stack} {\n${renderErrorCause(e.cause as Cause.PrettyError, "  ")}\n}`
   }).join("\n")
 }
 
-const renderErrorCause = (cause: PrettyError, prefix: string) => {
+const renderErrorCause = (cause: Cause.PrettyError, prefix: string) => {
   const lines = cause.stack!.split("\n")
   let stack = `${prefix}[cause]: ${lines[0]}`
   for (let i = 1, len = lines.length; i < len; i++) {
     stack += `\n${prefix}${lines[i]}`
   }
   if (cause.cause) {
-    stack += ` {\n${renderErrorCause(cause.cause as PrettyError, `${prefix}  `)}\n${prefix}}`
+    stack += ` {\n${renderErrorCause(cause.cause as Cause.PrettyError, `${prefix}  `)}\n${prefix}}`
   }
   return stack
 }
 
 /** @internal */
-export class PrettyError extends globalThis.Error implements Cause.PrettyError {
-  span: undefined | Span = undefined
-  constructor(originalError: unknown) {
-    const originalErrorIsObject = typeof originalError === "object" && originalError !== null
-    const prevLimit = Error.stackTraceLimit
-    Error.stackTraceLimit = 1
-    super(
-      prettyErrorMessage(originalError),
-      originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
-        ? { cause: new PrettyError(originalError.cause) }
-        : undefined
-    )
-    if (this.message === "") {
-      this.message = "An error has occurred"
+export const makePrettyError = (originalError: unknown): Cause.PrettyError => {
+  const originalErrorIsObject = typeof originalError === "object" && originalError !== null
+  const prevLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = 1
+  const error = new Error(
+    prettyErrorMessage(originalError),
+    originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
+      ? { cause: makePrettyError(originalError.cause) }
+      : undefined
+  ) as Types.Mutable<Cause.PrettyError>
+  Error.stackTraceLimit = prevLimit
+  if (error.message === "") {
+    error.message = "An error has occurred"
+  }
+  Error.stackTraceLimit = prevLimit
+  error.name = originalError instanceof Error ? originalError.name : "Error"
+  if (originalErrorIsObject) {
+    if (spanSymbol in originalError) {
+      error.span = originalError[spanSymbol] as Span
     }
-    Error.stackTraceLimit = prevLimit
-    this.name = originalError instanceof Error ? originalError.name : "Error"
-    if (originalErrorIsObject) {
-      if (spanSymbol in originalError) {
-        this.span = originalError[spanSymbol] as Span
+    Object.keys(originalError).forEach((key) => {
+      if (!(key in error)) {
+        // @ts-expect-error
+        error[key] = originalError[key]
       }
-      Object.keys(originalError).forEach((key) => {
-        if (!(key in this)) {
-          // @ts-expect-error
-          this[key] = originalError[key]
-        }
-      })
-    }
-    this.stack = prettyErrorStack(
-      `${this.name}: ${this.message}`,
-      originalError instanceof Error && originalError.stack
-        ? originalError.stack
-        : "",
-      this.span
-    )
+    })
   }
+  error.stack = prettyErrorStack(
+    `${error.name}: ${error.message}`,
+    originalError instanceof Error && originalError.stack
+      ? originalError.stack
+      : "",
+    error.span
+  )
+  return error
 }
 
 /**
@@ -1035,14 +1034,14 @@ const prettyErrorStack = (message: string, stack: string, span?: Span | undefine
 export const spanSymbol = Symbol.for("effect/SpanAnnotation")
 
 /** @internal */
-export const prettyErrors = <E>(cause: Cause.Cause<E>): Array<PrettyError> =>
+export const prettyErrors = <E>(cause: Cause.Cause<E>): Array<Cause.PrettyError> =>
   reduceWithContext(cause, void 0, {
-    emptyCase: (): Array<PrettyError> => [],
+    emptyCase: (): Array<Cause.PrettyError> => [],
     dieCase: (_, unknownError) => {
-      return [new PrettyError(unknownError)]
+      return [makePrettyError(unknownError)]
     },
     failCase: (_, error) => {
-      return [new PrettyError(error)]
+      return [makePrettyError(error)]
     },
     interruptCase: () => [],
     parallelCase: (_, l, r) => [...l, ...r],

package/src/internal/core-effect.ts

@@ -1966,7 +1966,7 @@ export const annotateCurrentSpan: {
 } = function(): Effect.Effect<void> {
   const args = arguments
   return ignore(core.flatMap(
-    currentSpan,
+    currentPropagatedSpan,
     (span) =>
       core.sync(() => {
         if (typeof args[0] === "string") {
@@ -2041,6 +2041,16 @@ export const currentSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementExceptio
   }
 )
 
+export const currentPropagatedSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementException> = core.flatMap(
+  core.context<never>(),
+  (context) => {
+    const span = filterDisablePropagation(Context.getOption(context, internalTracer.spanTag))
+    return span._tag === "Some" && span.value._tag === "Span"
+      ? core.succeed(span.value)
+      : core.fail(new core.NoSuchElementException())
+  }
+)
+
 /* @internal */
 export const linkSpans = dual<
   (
@@ -2070,12 +2080,13 @@ export const linkSpans = dual<
 
 const bigint0 = BigInt(0)
 
-const filterDisablePropagation: (self: Option.Option<Tracer.AnySpan>) => Option.Option<Tracer.AnySpan> = Option.flatMap(
-  (span) =>
-    Context.get(span.context, internalTracer.DisablePropagation)
-      ? span._tag === "Span" ? filterDisablePropagation(span.parent) : Option.none()
-      : Option.some(span)
-)
+export const filterDisablePropagation: (self: Option.Option<Tracer.AnySpan>) => Option.Option<Tracer.AnySpan> = Option
+  .flatMap(
+    (span) =>
+      Context.get(span.context, internalTracer.DisablePropagation)
+        ? span._tag === "Span" ? filterDisablePropagation(span.parent) : Option.none()
+        : Option.some(span)
+  )
 
 /** @internal */
 export const unsafeMakeSpan = <XA, XE>(

package/src/internal/fiberRuntime.ts

@@ -1522,13 +1522,15 @@ export const tracerLogger = globalValue(
       logLevel,
       message
     }) => {
-      const span = Context.getOption(
+      const span = internalEffect.filterDisablePropagation(Context.getOption(
         fiberRefs.getOrDefault(context, core.currentContext),
         tracer.spanTag
-      )
+      ))
+
       if (span._tag === "None" || span.value._tag === "ExternalSpan") {
         return
       }
+
       const clockService = Context.unsafeGet(
         fiberRefs.getOrDefault(context, defaultServices.currentServices),
         clock.clockTag

package/src/internal/logger.ts

@@ -456,7 +456,7 @@ const prettyLoggerBrowser = (options: {
       console.groupCollapsed(firstLine, ...firstParams)
 
       if (!Cause.isEmpty(cause)) {
-        console.error(Cause.pretty(cause, { renderErrorCause: true }))
+        console.error(...Cause.prettyErrors(cause))
       }
 
       if (messageIndex < message.length) {

package/src/internal/rcMap.ts

@@ -4,7 +4,7 @@ import type * as Deferred from "../Deferred.js"
 import * as Duration from "../Duration.js"
 import type { Effect } from "../Effect.js"
 import type { RuntimeFiber } from "../Fiber.js"
-import { dual, identity } from "../Function.js"
+import { constant, dual, flow, identity } from "../Function.js"
 import * as MutableHashMap from "../MutableHashMap.js"
 import { pipeArguments } from "../Pipeable.js"
 import type * as RcMap from "../RcMap.js"
@@ -33,6 +33,7 @@ declare namespace State {
     readonly deferred: Deferred.Deferred<A, E>
     readonly scope: Scope.CloseableScope
     readonly finalizer: Effect<void>
+    readonly idleTimeToLive: Duration.Duration
     fiber: RuntimeFiber<void, never> | undefined
     expiresAt: number
     refCount: number
@@ -58,7 +59,7 @@ class RcMapImpl<K, A, E> implements RcMap.RcMap<K, A, E> {
     readonly lookup: (key: K) => Effect<A, E, Scope.Scope>,
     readonly context: Context.Context<never>,
     readonly scope: Scope.Scope,
-    readonly idleTimeToLive: Duration.Duration | undefined,
+    readonly idleTimeToLive: ((key: K) => Duration.Duration) | undefined,
     readonly capacity: number
   ) {
     this[TypeId] = variance
@@ -73,27 +74,32 @@ class RcMapImpl<K, A, E> implements RcMap.RcMap<K, A, E> {
 export const make: {
   <K, A, E, R>(options: {
     readonly lookup: (key: K) => Effect<A, E, R>
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
     readonly capacity?: undefined
   }): Effect<RcMap.RcMap<K, A, E>, never, Scope.Scope | R>
   <K, A, E, R>(options: {
     readonly lookup: (key: K) => Effect<A, E, R>
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
     readonly capacity: number
   }): Effect<RcMap.RcMap<K, A, E | Cause.ExceededCapacityException>, never, Scope.Scope | R>
 } = <K, A, E, R>(options: {
   readonly lookup: (key: K) => Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
   readonly capacity?: number | undefined
 }) =>
   core.withFiberRuntime<RcMap.RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
     const context = fiber.getFiberRef(core.currentContext) as Context.Context<R | Scope.Scope>
     const scope = Context.get(context, fiberRuntime.scopeTag)
+    const idleTimeToLive = options.idleTimeToLive === undefined
+      ? undefined
+      : typeof options.idleTimeToLive === "function"
+      ? flow(options.idleTimeToLive, Duration.decode)
+      : constant(Duration.decode(options.idleTimeToLive))
     const self = new RcMapImpl<K, A, E>(
       options.lookup as any,
       context,
       scope,
-      options.idleTimeToLive ? Duration.decode(options.idleTimeToLive) : undefined,
+      idleTimeToLive,
       Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
     )
     return core.as(
@@ -169,10 +175,12 @@ const acquire = core.fnUntraced(function*<K, A, E>(self: RcMapImpl<K, A, E>, key
     core.flatMap((exit) => core.deferredDone(deferred, exit)),
     circular.forkIn(scope)
   )
+  const idleTimeToLive = self.idleTimeToLive ? self.idleTimeToLive(key) : Duration.zero
   const entry: State.Entry<A, E> = {
     deferred,
     scope,
     finalizer: undefined as any,
+    idleTimeToLive,
     fiber: undefined,
     expiresAt: 0,
     refCount: 1
@@ -192,7 +200,7 @@ const release = <K, A, E>(self: RcMapImpl<K, A, E>, key: K, entry: State.Entry<A
     } else if (
       self.state._tag === "Closed"
       || !MutableHashMap.has(self.state.map, key)
-      || self.idleTimeToLive === undefined
+      || Duration.isZero(entry.idleTimeToLive)
     ) {
       if (self.state._tag === "Open") {
         MutableHashMap.remove(self.state.map, key)
@@ -200,11 +208,11 @@ const release = <K, A, E>(self: RcMapImpl<K, A, E>, key: K, entry: State.Entry<A
       return core.scopeClose(entry.scope, core.exitVoid)
     }
 
-    if (!Duration.isFinite(self.idleTimeToLive)) {
+    if (!Duration.isFinite(entry.idleTimeToLive)) {
       return core.void
     }
 
-    entry.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(self.idleTimeToLive)
+    entry.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(entry.idleTimeToLive)
     if (entry.fiber) return core.void
 
     return core.interruptibleMask(function loop(restore): Effect<void> {
@@ -276,10 +284,12 @@ export const touch: {
   <K, A, E>(self_: RcMap.RcMap<K, A, E>, key: K) =>
     coreEffect.clockWith((clock) => {
       const self = self_ as RcMapImpl<K, A, E>
-      if (!self.idleTimeToLive || self.state._tag === "Closed") return core.void
+      if (self.state._tag === "Closed") return core.void
       const o = MutableHashMap.get(self.state.map, key)
       if (o._tag === "None") return core.void
-      o.value.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(self.idleTimeToLive)
+      const entry = o.value
+      if (Duration.isZero(entry.idleTimeToLive)) return core.void
+      entry.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(entry.idleTimeToLive)
       return core.void
     })
 )

package/src/internal/version.ts

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