effect 4.0.0-beta.87 → 4.0.0-beta.89

package/src/unstable/http/HttpClient.ts

@@ -1299,6 +1299,10 @@ export declare namespace WithRateLimiter {
      * Disable automatic limits updates from response headers.
      */
     readonly disableResponseInspection?: boolean | undefined
+    /**
+     * Disable adaptive learning from `Retry-After` responses.
+     */
+    readonly disableAdaptiveLearning?: boolean | undefined
   }
 }
 
@@ -1362,6 +1366,7 @@ export const withRateLimiter: {
   const resolveTokens: (request: HttpClientRequest.HttpClientRequest) => number = typeof tokensOption === "function"
     ? tokensOption
     : constant(tokensOption ?? 1)
+  const adaptiveLearningEnabled = !options.disableAdaptiveLearning
 
   const getState = (key: string): RateLimiterState => {
     const current = states.get(key)
@@ -1392,13 +1397,75 @@ export const withRateLimiter: {
     const key = resolveKey(request)
     const tokens = Math.max(resolveTokens(request), 1)
     const current = getState(key)
-    function retry(response: HttpClientResponse.HttpClientResponse) {
+    function retry(retryAfter: Duration.Duration | undefined) {
       if (options.disableResponseInspection) return loop(effect, request)
-      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, "retry-after"))
       return retryAfter
         ? Effect.flatMap(Effect.sleep(retryAfter), () => loop(effect, request))
         : loop(effect, request)
     }
+    const inspectResponse = (
+      response: HttpClientResponse.HttpClientResponse,
+      adaptive: RateLimiter.AdaptiveConsumeResult | undefined
+    ) => {
+      onResponse?.(clock, key, response.headers, tokens)
+      if (options.disableResponseInspection || response.status !== 429) {
+        return Effect.succeed</**
+         * Applies request rate limiting using the `RateLimiter` service.
+         *
+         * **Details**
+         *
+         * 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.
+         *
+         * @category rate limiting
+         * @since 4.0.0
+         */
+        Duration.Duration | undefined>(undefined);
+      }
+      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, "retry-after"))
+      if (retryAfter === undefined) {
+        return Effect.succeed</**
+         * Applies request rate limiting using the `RateLimiter` service.
+         *
+         * **Details**
+         *
+         * 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.
+         *
+         * @category rate limiting
+         * @since 4.0.0
+         */
+        Duration.Duration | undefined>(undefined);
+      }
+      const delay = parseRateLimitWindow(clock, response.headers) ?? retryAfter
+      if (adaptive === undefined) {
+        return Effect.succeed</**
+         * Applies request rate limiting using the `RateLimiter` service.
+         *
+         * **Details**
+         *
+         * 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.
+         *
+         * @category rate limiting
+         * @since 4.0.0
+         */
+        Duration.Duration | undefined>(delay);
+      }
+      return Effect.as(
+        options.limiter.adaptiveFeedback({
+          key,
+          epoch: adaptive.epoch,
+          tokens,
+          status: response.status,
+          retryAfter: delay
+        }),
+        delay
+      )
+    }
     return Effect.flatMap(
       options.limiter.consume({
         algorithm: options.algorithm,
@@ -1409,24 +1476,55 @@ export const withRateLimiter: {
         tokens
       }),
       ({ delay }) => {
-        const run = Effect.matchEffect(effect, {
-          onSuccess(response) {
-            onResponse?.(clock, key, response.headers, tokens)
-            if (response.status !== 429) return Effect.succeed(response)
-            return retry(response)
-          },
-          onFailure(error) {
-            if (isTooManyRequestsHttpClientError(error)) {
-              onResponse?.(clock, key, error.reason.response.headers, tokens)
-              return retry(error.reason.response)
-            }
-            return Effect.fail(error)
+        const runAdaptive = (): Effect.Effect<
+          HttpClientResponse.HttpClientResponse,
+          E | RateLimiter.RateLimiterError,
+          R
+        > => {
+          const runRequest = (adaptive: RateLimiter.AdaptiveConsumeResult | undefined) => {
+            const request = Effect.matchEffect(effect, {
+              onSuccess(response) {
+                return Effect.flatMap(inspectResponse(response, adaptive), (retryAfter) => {
+                  if (response.status !== 429) return Effect.succeed(response)
+                  return retry(retryAfter)
+                })
+              },
+              onFailure(error) {
+                if (isTooManyRequestsHttpClientError(error)) {
+                  return Effect.flatMap(
+                    inspectResponse(error.reason.response, adaptive),
+                    (retryAfter) => retry(retryAfter)
+                  )
+                }
+                return Effect.fail(error)
+              }
+            })
+            return adaptive === undefined || Duration.isZero(adaptive.delay)
+              ? request
+              : Effect.delay(request, adaptive.delay)
           }
-        })
-        return Duration.isZero(delay) ? run : Effect.delay(run, delay)
+          if (!adaptiveLearningEnabled) {
+            return runRequest(undefined)
+          }
+          return Effect.flatMap(
+            options.limiter.adaptiveConsume({
+              key,
+              tokens,
+              fallbackLimit: current.limit,
+              fallbackWindow: current.window
+            }),
+            (adaptive) => {
+              if (!Duration.isZero(adaptive.delay) && adaptive.phase === "cooldown") {
+                return Effect.flatMap(Effect.sleep(adaptive.delay), runAdaptive)
+              }
+              return runRequest(adaptive)
+            }
+          )
+        }
+        return Duration.isZero(delay) ? runAdaptive() : Effect.flatMap(Effect.sleep(delay), runAdaptive)
       }
     )
-  })
+  });
 })
 
 interface RateLimiterState {
@@ -1476,13 +1574,6 @@ const parseRateLimitWindow = (
   clock: Clock,
   headers: Headers.Headers
 ): Duration.Duration | undefined => {
-  const retryAfter = parseRetryAfter(
-    clock,
-    getHeader(headers, "retry-after")
-  )
-  if (retryAfter !== undefined) {
-    return retryAfter
-  }
   const resetAfter = parseResetAfter(getHeader(headers, "ratelimit-reset-after", "x-ratelimit-reset-after"))
   if (resetAfter !== undefined) {
     return resetAfter

package/src/unstable/observability/OtlpTracer.ts

@@ -17,6 +17,7 @@ import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
+import { renderPrettyError } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
@@ -311,7 +312,7 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
             {
               "key": "exception.stacktrace",
               "value": {
-                "stringValue": error.stack ?? "No stack trace available"
+                "stringValue": renderPrettyError(error) ?? "No stack trace available"
               }
             }
           ]