effect 4.0.2 → 4.0.3

package/src/cluster/internal/entityManager.ts

@@ -86,6 +86,10 @@ export interface Residency {
   readonly releaseUnsafe: () => void
 }
 
+interface RequestTransaction {
+  settle?: ((outcome: Exit.Exit<unknown, unknown>) => Effect.Effect<void>) | undefined
+}
+
 // Represents the entities managed by this entity manager
 /**
  * @internal
@@ -100,10 +104,13 @@ export type EntityState = {
     /** Excludes requests awaiting their first dispatch from replay. */
     delivered: boolean
     sentExit: boolean
+    /** Treat early termination interrupts like shutdown interrupts. */
+    terminating?: boolean | undefined
     lastSentChunk: Option.Option<Reply.Chunk<Rpc.Any>>
     sequence: number
     /** Set when the request should not outlive its caller. */
     callerScope?: Scope.Scope | undefined
+    transaction?: RequestTransaction | undefined
   }>
   lastActiveCheck: number
   write: RpcServer.RpcServer<any>["write"]
@@ -152,9 +159,13 @@ export const make = Effect.fnUntraced(function*<
   entityRpcs.set(KeepAliveRpc._tag, KeepAliveRpc as any)
 
   const activeServers = new Map<EntityId, EntityState>()
+  // Entities finishing their in-flight requests after removal, which still
+  // accept interrupts and acks
+  const drainingServers = new Map<EntityId, EntityState>()
   const serverCloseLatches = new Map<EntityAddress, {
     readonly closed: Latch.Latch
     readonly force: Latch.Latch
+    closing: boolean
   }>()
   const processedRequestIds = new Set<Snowflake.Snowflake>()
 
@@ -181,7 +192,8 @@ export const make = Effect.fnUntraced(function*<
     const keepAliveLatch = Latch.makeUnsafe()
     const closeLatches = {
       closed: Latch.makeUnsafe(),
-      force: Latch.makeUnsafe()
+      force: Latch.makeUnsafe(),
+      closing: false
     }
 
     yield* Scope.addFinalizer(
@@ -264,22 +276,23 @@ export const make = Effect.fnUntraced(function*<
                 // They will be retried when the entity is restarted.
                 // Also, if the request is uninterruptible, we ignore the
                 // interrupt.
+                const persisted = storageEnabled && Context.get(request.message.annotations, Persisted)
                 if (
-                  storageEnabled &&
-                  Context.get(request.message.annotations, Persisted) &&
+                  persisted &&
                   Exit.hasInterrupts(response.exit) &&
-                  (isShuttingDown || isUninterruptibleForServer(request.message.annotations))
+                  (isShuttingDown || request.terminating || isUninterruptibleForServer(request.message.annotations))
                 ) {
-                  if (!isShuttingDown) {
+                  if (!isShuttingDown && !request.terminating) {
                     request.sentExit = false
                     return server.write(0, requestEnvelope(request), requestWriteOptions(request)).pipe(
+                      Effect.setContext(handlerContext),
                       Effect.forkIn(handlerScope)
                     )
                   }
                   activeRequests.delete(Snowflake.Snowflake(response.requestId))
                   return options.storage.unregisterReplyHandler(request.message.envelope.requestId)
                 }
-                return retryRespond(
+                const save = retryRespond(
                   4,
                   Effect.suspend(() =>
                     request.message.respond(
@@ -290,22 +303,53 @@ export const make = Effect.fnUntraced(function*<
                       })
                     )
                   )
-                ).pipe(
-                  Effect.flatMap(() => {
-                    if (storageEnabled) {
-                      processedRequestIds.add(request.message.envelope.requestId)
-                    }
-                    activeRequests.delete(Snowflake.Snowflake(response.requestId))
+                )
+                const complete = Effect.sync(() => {
+                  if (storageEnabled) {
+                    processedRequestIds.add(request.message.envelope.requestId)
+                  }
+                  activeRequests.delete(Snowflake.Snowflake(response.requestId))
 
-                    // Start the idle timer when the last request completes.
-                    if (activeRequests.size === 0) {
-                      state.lastActiveCheck = clock.currentTimeMillisUnsafe()
-                    }
+                  // Start the idle timer when the last request completes.
+                  if (activeRequests.size === 0) {
+                    state.lastActiveCheck = clock.currentTimeMillisUnsafe()
+                  }
+                })
+                const respond = Effect.orDie(Effect.andThen(save, complete))
+                const transaction = request.transaction
+                if (!transaction) return respond
+                const exit = response.exit
+
+                if (!persisted) {
+                  if (Exit.isSuccess(exit)) return respond
+                  transaction.settle = () => respond
+                  return Effect.void
+                }
 
-                    return Effect.void
-                  }),
-                  Effect.orDie
-                )
+                if (Exit.isSuccess(exit)) {
+                  transaction.settle = (outcome) =>
+                    Exit.isSuccess(outcome) ? complete : Effect.flatMap(
+                      hasStoredExit(request.message.envelope.requestId),
+                      (committed) => {
+                        if (!committed) return restartFrom(outcome.cause)
+                        // Commit succeeded despite the error; let callers read the saved reply.
+                        return Effect.andThen(
+                          complete,
+                          options.storage.unregisterReplyHandler(request.message.envelope.requestId)
+                        )
+                      }
+                    )
+                  return Effect.orDie(save)
+                }
+                transaction.settle = (outcome) =>
+                  // Transaction wrappers can add defects, but not typed errors; interrupts may be repeated.
+                  Exit.isSuccess(outcome) || !outcome.cause.reasons.some((reason) =>
+                      Cause.isDieReason(reason) &&
+                      !exit.cause.reasons.some((r) => Cause.isDieReason(r) && r.defect === reason.defect)
+                    )
+                    ? respond
+                    : restartFrom(outcome.cause)
+                return Effect.void
               }
               case "Chunk": {
                 const request = activeRequests.get(Snowflake.Snowflake(response.requestId))
@@ -330,10 +374,7 @@ export const make = Effect.fnUntraced(function*<
                 ))
               }
               case "Defect": {
-                if (!isActive()) return endLatch.open
-                const rebuild = writeRef.rebuildUnsafe({ from: server.write, prepare: replay })
-                if (!rebuild) return Effect.void
-                return Effect.forkIn(restart(Cause.die(response.defect), rebuild), managerScope)
+                return restartFrom(Cause.die(response.defect))
               }
               case "ClientEnd": {
                 return endLatch.open
@@ -345,6 +386,21 @@ export const make = Effect.fnUntraced(function*<
           Effect.setContext(Context.merge(handlerContext, handlers))
         )
 
+        // Replay if the stored reply cannot be read.
+        const hasStoredExit = (requestId: Snowflake.Snowflake): Effect.Effect<boolean> =>
+          options.storage.repliesForUnfiltered([requestId]).pipe(
+            Effect.map((replies) => replies.some((reply) => reply._tag === "WithExit")),
+            Effect.catchCause(() => Effect.succeed(false))
+          )
+
+        // Do not inherit the failed handler's transaction context.
+        const restartFrom = (cause: Cause.Cause<unknown>): Effect.Effect<void> => {
+          if (!isActive()) return endLatch.open
+          const rebuild = writeRef.rebuildUnsafe({ from: server.write, prepare: replay })
+          if (!rebuild) return Effect.void
+          return Effect.forkIn(Effect.setContext(restart(cause, rebuild), handlerContext), managerScope)
+        }
+
         yield* Scope.addFinalizer(
           handlerScope,
           Effect.sync(() => {
@@ -415,15 +471,32 @@ export const make = Effect.fnUntraced(function*<
       Effect.suspend(() => {
         activeServers.delete(address.entityId)
         retired.openUnsafe()
+        closeLatches.closing = true
         acquireEntity(address)
+        drainingServers.set(address.entityId, state)
         return Effect.raceFirst(
-          state.write(0, { _tag: "Eof" }).pipe(
+          Effect.gen(function*() {
+            for (const [requestId, request] of activeRequests) {
+              if (
+                !request.delivered || request.sentExit ||
+                !Context.get(request.message.annotations, ClusterSchema.InterruptOnTermination) ||
+                isUninterruptibleForServer(request.message.annotations)
+              ) continue
+              request.terminating = true
+              yield* state.write(0, { _tag: "Interrupt", requestId: requestId as any, interruptors: [] })
+            }
+            yield* state.write(0, { _tag: "Eof" })
+          }).pipe(
             Effect.andThen(endLatch.await),
             Effect.timeoutOption(config.entityTerminationTimeout),
             Effect.interruptible
           ),
           Effect.interruptible(closeLatches.force.await)
-        )
+        ).pipe(Effect.ensuring(Effect.sync(() => {
+          if (drainingServers.get(address.entityId) === state) {
+            drainingServers.delete(address.entityId)
+          }
+        })))
       })
     )
     if (!options.sharding.hasShardId(address.shardId)) {
@@ -458,9 +531,38 @@ export const make = Effect.fnUntraced(function*<
     Effect.forkIn(managerScope)
   )
 
+  function sendEnvelope(server: EntityState, message: Message.IncomingEnvelope): Effect.Effect<void> {
+    const entry = server.activeRequests.get(message.envelope.requestId)
+    if (!entry) {
+      return Effect.void
+    } else if (
+      message.envelope._tag === "AckChunk" &&
+      Option.isSome(entry.lastSentChunk) &&
+      message.envelope.replyId !== entry.lastSentChunk.value.id
+    ) {
+      return Effect.void
+    }
+    return server.write(
+      0,
+      message.envelope._tag === "AckChunk"
+        ? { _tag: "Ack", requestId: message.envelope.requestId as any }
+        : {
+          _tag: "Interrupt",
+          requestId: message.envelope.requestId as any,
+          interruptors: []
+        }
+    )
+  }
+
   function sendLocal<R extends Rpc.Any>(
     message: Message.IncomingLocal<R>
   ): Effect.Effect<void, EntityNotAssignedToRunner | MailboxFull | AlreadyProcessingMessage> {
+    if (message._tag === "IncomingEnvelope") {
+      const draining = drainingServers.get(message.envelope.address.entityId)
+      if (draining?.activeRequests.has(message.envelope.requestId)) {
+        return sendEnvelope(draining, message)
+      }
+    }
     return Effect.provideService(
       Effect.flatMap(
         entities.get(message.envelope.address),
@@ -557,26 +659,7 @@ export const make = Effect.fnUntraced(function*<
               return server.write(0, requestEnvelope(entry), requestWriteOptions(entry))
             }
             case "IncomingEnvelope": {
-              const entry = server.activeRequests.get(message.envelope.requestId)
-              if (!entry) {
-                return Effect.void
-              } else if (
-                message.envelope._tag === "AckChunk" &&
-                Option.isSome(entry.lastSentChunk) &&
-                message.envelope.replyId !== entry.lastSentChunk.value.id
-              ) {
-                return Effect.void
-              }
-              return server.write(
-                0,
-                message.envelope._tag === "AckChunk"
-                  ? { _tag: "Ack", requestId: message.envelope.requestId as any }
-                  : {
-                    _tag: "Interrupt",
-                    requestId: message.envelope.requestId as any,
-                    interruptors: []
-                  }
-              )
+              return sendEnvelope(server, message)
             }
           }
         }
@@ -596,11 +679,24 @@ export const make = Effect.fnUntraced(function*<
     })
 
   const requestWriteOptions = (
-    entry: { readonly message: Message.IncomingRequestLocal<any>; readonly callerScope?: Scope.Scope | undefined }
+    entry: {
+      readonly message: Message.IncomingRequestLocal<any>
+      readonly callerScope?: Scope.Scope | undefined
+      transaction?: RequestTransaction | undefined
+    }
   ): Parameters<EntityState["write"]>[2] => {
-    const onTransaction = Context.get(entry.message.annotations, WithTransaction)
-      ? options.storage.withTransaction
-      : undefined
+    const onTransaction = !Context.get(entry.message.annotations, WithTransaction)
+      ? undefined
+      : <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        // Interrupts during commit must not hide the outcome from settle.
+        Effect.uninterruptibleMask((restore) => {
+          const transaction: RequestTransaction = {}
+          entry.transaction = transaction
+          return Effect.onExit(options.storage.withTransaction(restore(effect)), (outcome) => {
+            if (entry.transaction === transaction) entry.transaction = undefined
+            return transaction.settle ? transaction.settle(outcome) : Effect.void
+          })
+        })
     const onCaller = entry.callerScope && bindToCaller(entry.callerScope)
     if (!onCaller) return onTransaction && { onRequest: onTransaction }
     return { onRequest: onTransaction ? (effect) => onCaller(onTransaction(effect)) : onCaller }
@@ -621,13 +717,13 @@ export const make = Effect.fnUntraced(function*<
             }
           })
         }
-        activeServers.forEach((state) => {
-          if (shardId[Equal.symbol](state.address.shardId)) {
-            fibers.push(runFork(entities.removeIgnore(state.address)))
-          }
-        })
+        // Look entities up by address: `activeServers` is keyed by entity id,
+        // so an entity with the same id on another shard can hide this one.
         serverCloseLatches.forEach((latches, address) => {
           if (shardId[Equal.symbol](address.shardId)) {
+            if (!latches.closing) {
+              fibers.push(runFork(entities.removeIgnore(address)))
+            }
             fibers.push(runFork(latches.closed.await))
           }
         })

package/src/http/FindMyWay/internal/router.ts

@@ -338,13 +338,6 @@ class RouterImpl<A> implements Router.Router<A> {
         path = path.replace(FULL_PATH_REGEXP, "/")
       }
 
-      // This must be run before sanitizeUrl as the resulting function
-      // .sliceParameter must be constructed with same URL string used
-      // throughout the rest of this function.
-      if (this.options.ignoreDuplicateSlashes) {
-        path = removeDuplicateSlashes(path)
-      }
-
       let sanitizedUrl
       try {
         sanitizedUrl = safeDecodeURI(path)
@@ -355,6 +348,10 @@ class RouterImpl<A> implements Router.Router<A> {
         return undefined
       }
 
+      if (this.options.ignoreDuplicateSlashes) {
+        path = removeDuplicateSlashes(path)
+      }
+
       if (this.options.ignoreTrailingSlash) {
         path = trimLastSlash(path)
       }

package/src/http/HttpClient.ts

@@ -1466,6 +1466,8 @@ export declare namespace WithRateLimiter {
  * It can update limits by inspecting common rate limit response headers and
  * automatically retries HTTP `429` responses (or `HttpClientError` values
  * wrapping a `429` response) by forcing the retry back through the limiter.
+ * When a response reports the remaining budget, requests wait for the
+ * reported reset once that budget is exhausted.
  *
  * **Gotchas**
  *
@@ -1486,6 +1488,8 @@ export const withRateLimiter: {
    * It can update limits by inspecting common rate limit response headers and
    * automatically retries HTTP `429` responses (or `HttpClientError` values
    * wrapping a `429` response) by forcing the retry back through the limiter.
+   * When a response reports the remaining budget, requests wait for the
+   * reported reset once that budget is exhausted.
    *
    * **Gotchas**
    *
@@ -1508,6 +1512,8 @@ export const withRateLimiter: {
    * It can update limits by inspecting common rate limit response headers and
    * automatically retries HTTP `429` responses (or `HttpClientError` values
    * wrapping a `429` response) by forcing the retry back through the limiter.
+   * When a response reports the remaining budget, requests wait for the
+   * reported reset once that budget is exhausted.
    *
    * **Gotchas**
    *
@@ -1551,14 +1557,36 @@ export const withRateLimiter: {
     return initialState
   }
 
+  const budgets = new Map<string, RateLimitBudget>()
+  const getBudget = (key: string): RateLimitBudget => {
+    let budget = budgets.get(key)
+    if (budget === undefined) {
+      budget = { sent: 0, observed: 0, remaining: 0, resetAt: 0 }
+      budgets.set(key, budget)
+    }
+    return budget
+  }
+
   const onResponse = options.disableResponseInspection
     ? undefined
-    : (clock: Clock, key: string, headers: Headers.Headers, tokens: number) => {
+    : (clock: Clock, key: string, headers: Headers.Headers, tokens: number, sent: number) => {
       const current = getState(key)
       const next = parseRateLimiterState(current, clock, headers, tokens, headerNames)
       if (next.limit !== current.limit || !Duration.equals(next.window, current.window)) {
         states.set(key, next)
       }
+      const remaining = parseRateLimitRemaining(headers, headerNames)
+      const budget = getBudget(key)
+      // responses to earlier requests carry stale counts
+      if (remaining === undefined || sent <= budget.observed) {
+        return
+      }
+      const resetAfter = parseRateLimitWindow(clock, headers, headerNames)
+      budget.observed = sent
+      budget.remaining = remaining
+      if (resetAfter !== undefined) {
+        budget.resetAt = clock.currentTimeMillisUnsafe() + Duration.toMillis(resetAfter)
+      }
     }
 
   return transform(self, function loop(effect, request, retries = 0): Effect.Effect<
@@ -1570,6 +1598,15 @@ export const withRateLimiter: {
     const clock = fiber.getRef(Clock)
     const key = resolveKey(request)
     const tokens = Math.max(resolveTokens(request), 1)
+    const budget = getBudget(key)
+    const now = clock.currentTimeMillisUnsafe()
+    // requests admitted after the observed one are not reflected in its count
+    if (budget.resetAt > now && budget.remaining - (budget.sent - budget.observed) < tokens) {
+      return Effect.flatMap(Effect.sleep(budget.resetAt - now), () => loop(effect, request, retries))
+    }
+    // counted at admission, so requests already admitted are sent even if a
+    // later response exhausts the budget
+    const sent = budget.sent += tokens
     const current = getState(key)
     const canRetry = options.times === undefined || retries < options.times
     function retry(retryAfter: Duration.Duration | undefined) {
@@ -1581,7 +1618,7 @@ export const withRateLimiter: {
       response: HttpClientResponse.HttpClientResponse,
       adaptive: RateLimiter.AdaptiveConsumeResult | undefined
     ) => {
-      onResponse?.(clock, key, response.headers, tokens)
+      onResponse?.(clock, key, response.headers, tokens, sent)
       if (options.disableResponseInspection || response.status !== 429) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1591,6 +1628,8 @@ export const withRateLimiter: {
          * It can update limits by inspecting common rate limit response headers and
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
+         * When a response reports the remaining budget, requests wait for the
+         * reported reset once that budget is exhausted.
          *
          * **Gotchas**
          *
@@ -1614,6 +1653,8 @@ export const withRateLimiter: {
          * It can update limits by inspecting common rate limit response headers and
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
+         * When a response reports the remaining budget, requests wait for the
+         * reported reset once that budget is exhausted.
          *
          * **Gotchas**
          *
@@ -1637,6 +1678,8 @@ export const withRateLimiter: {
          * It can update limits by inspecting common rate limit response headers and
          * automatically retries HTTP `429` responses (or `HttpClientError` values
          * wrapping a `429` response) by forcing the retry back through the limiter.
+         * When a response reports the remaining budget, requests wait for the
+         * reported reset once that budget is exhausted.
          *
          * **Gotchas**
          *
@@ -1756,6 +1799,17 @@ interface RateLimiterState {
   readonly initial: boolean
 }
 
+interface RateLimitBudget {
+  /** Total tokens admitted for the key. */
+  sent: number
+  /** The `sent` total of the request whose remaining count was last applied. */
+  observed: number
+  /** The remaining count reported in response to the `observed` request. */
+  remaining: number
+  /** When the server budget resets, in epoch milliseconds. */
+  resetAt: number
+}
+
 const parseRateLimiterState = (
   state: RateLimiterState,
   clock: Clock,

package/src/http/HttpTraceContext.ts

@@ -93,7 +93,7 @@ export const b3: FromHeaders = (headers) => {
     return Option.none()
   }
   const parts = headers["b3"].split("-")
-  if (parts.length < 2) {
+  if (parts.length < 2 || isB3Ids(parts[0], parts[1]) === false) {
     return Option.none()
   }
   return Option.some(Tracer.externalSpan({
@@ -116,7 +116,10 @@ export const b3: FromHeaders = (headers) => {
  * @since 4.0.0
  */
 export const xb3: FromHeaders = (headers) => {
-  if (!(headers["x-b3-traceid"]) || !(headers["x-b3-spanid"])) {
+  if (
+    !(headers["x-b3-traceid"]) || !(headers["x-b3-spanid"]) ||
+    isB3Ids(headers["x-b3-traceid"], headers["x-b3-spanid"]) === false
+  ) {
     return Option.none()
   }
   return Option.some(Tracer.externalSpan({
@@ -130,6 +133,9 @@ export const xb3: FromHeaders = (headers) => {
 const w3cTraceId = /^[0-9a-f]{32}$/i
 const w3cSpanId = /^[0-9a-f]{16}$/i
 
+const b3TraceId = /^(?:[0-9a-f]{16}|[0-9a-f]{32})$/i
+const isB3Ids = (traceId: string, spanId: string): boolean => b3TraceId.test(traceId) && w3cSpanId.test(spanId)
+
 /**
  * Decodes an external span safely from the W3C `traceparent` header.
  *

package/src/internal/effect.ts

@@ -1507,6 +1507,7 @@ const succeedPayload = function(this: { readonly payload: any }, _value: unknown
 // V8 includes the property name of a stored continuation in its stack trace.
 // Other engines need an explicit frame for the stack cleaner to cut at.
 const continuationMarksStack = (() => {
+  if (getStackTraceLimit() === 0) return false
   const marker = "~effect/Effect/stackProbe"
   const probe = {
     [marker]: function stackProbe() {
@@ -4453,7 +4454,7 @@ export const cachedInvalidateWithTTL: {
 const infiniteTTL = constant(Infinity)
 
 interface CachedRun<A, E> {
-  fiber: FiberImpl<A, E> | undefined
+  readonly fiber: FiberImpl<A, E>
   awaiters: number
 }
 
@@ -4470,17 +4471,19 @@ const makeCachedUnsafe = <A, E, R>(
     onExitUnsafe(fiber, () => {
       // Abandon the run once every caller has left, unless it already finished.
       if (--run.awaiters > 0 || current !== run) return
-      // Detach it first so new callers start a fresh run instead of joining
-      // one that is being interrupted.
+      // Detach before interruption so new callers start a fresh run.
       current = undefined
-      return fiberInterrupt(run.fiber!)
+      return fiberInterrupt(run.fiber)
     })
-    return fiberJoin(run.fiber!)
+    return fiberJoin(run.fiber)
   }
 
   return [
     withFiber((fiber) => {
-      if (current !== undefined) return join(fiber, current)
+      if (current !== undefined) {
+        // A run joining itself is not an awaiter, so external callers can still abandon it.
+        return fiber === current.fiber ? fiberJoin(current.fiber) : join(fiber, current)
+      }
       if (
         exit !== undefined &&
         (expiresAt === Infinity || fiber.getRef(ClockRef).currentTimeMillisUnsafe() < expiresAt)
@@ -4489,10 +4492,11 @@ const makeCachedUnsafe = <A, E, R>(
       }
       exit = undefined
       const clock = fiber.getRef(ClockRef)
-      const run: CachedRun<A, E> = { fiber: undefined, awaiters: 0 }
+      const run: CachedRun<A, E> = { fiber: new FiberImpl(fiber.context), awaiters: 0 }
       current = run
-      run.fiber = forkUnsafe(
-        fiber,
+      // Join before evaluating, which may synchronously re-enter and interrupt other awaiters.
+      const joined = join(fiber, run)
+      run.fiber.evaluate(
         onExitPrimitive(self, (exit_) => {
           // An abandoned run must not overwrite or clear a replacement run.
           if (current !== run) return
@@ -4502,11 +4506,9 @@ const makeCachedUnsafe = <A, E, R>(
           const duration = ttlMillis(exit_)
           expiresAt = duration === Infinity ? Infinity : clock.currentTimeMillisUnsafe() + duration
           exit = exit_
-        }),
-        true,
-        true
+        }) as any
       )
-      return run.fiber._exit ?? join(fiber, run)
+      return run.fiber._exit ?? joined
     }),
     sync(() => {
       exit = undefined

package/src/internal/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = "4.0.2"
+export const version = "4.0.3"