req_retry | R Documentation |
req_retry()
alters req_perform()
so that it will automatically retry
in the case of failure. To activate it, you must specify either the total
number of requests to make with max_tries
or the total amount of time
to spend with max_seconds
. Then req_perform()
will retry if:
Either the HTTP request or HTTP response doesn't complete successfully leading to an error from curl, the lower-level library that httr2 uses to perform HTTP request. This occurs, for example, if your wifi is down.
The error is "transient", i.e. it's an HTTP error that can be resolved
by waiting. By default, 429 and 503 statuses are treated as transient,
but if the API you are wrapping has other transient status codes (or
conveys transient-ness with some other property of the response), you can
override the default with is_transient
.
It's a bad idea to immediately retry a request, so req_perform()
will
wait a little before trying again:
If the response contains the Retry-After
header, httr2 will wait the
amount of time it specifies. If the API you are wrapping conveys this
information with a different header (or other property of the response)
you can override the default behaviour with retry_after
.
Otherwise, httr2 will use "truncated exponential backoff with full
jitter", i.e. it will wait a random amount of time between one second and
2 ^ tries
seconds, capped to at most 60 seconds. In other words, it
waits runif(1, 1, 2)
seconds after the first failure, runif(1, 1, 4)
after the second, runif(1, 1, 8)
after the third, and so on. If you'd
prefer a different strategy, you can override the default with backoff
.
req_retry(
req,
max_tries = NULL,
max_seconds = NULL,
is_transient = NULL,
backoff = NULL,
after = NULL
)
req |
A request. |
max_tries, max_seconds |
Cap the maximum number of attempts with
|
is_transient |
A predicate function that takes a single argument
(the response) and returns |
backoff |
A function that takes a single argument (the number of failed attempts so far) and returns the number of seconds to wait. |
after |
A function that takes a single argument (the response) and
returns either a number of seconds to wait or |
A modified HTTP request.
req_throttle()
if the API has a rate-limit but doesn't expose
the limits in the response.
# google APIs assume that a 500 is also a transient error
request("http://google.com") |>
req_retry(is_transient = \(resp) resp_status(resp) %in% c(429, 500, 503))
# use a constant 10s delay after every failure
request("http://example.com") |>
req_retry(backoff = ~ 10)
# When rate-limited, GitHub's API returns a 403 with
# `X-RateLimit-Remaining: 0` and an Unix time stored in the
# `X-RateLimit-Reset` header. This takes a bit more work to handle:
github_is_transient <- function(resp) {
resp_status(resp) == 403 &&
identical(resp_header(resp, "X-RateLimit-Remaining"), "0")
}
github_after <- function(resp) {
time <- as.numeric(resp_header(resp, "X-RateLimit-Reset"))
time - unclass(Sys.time())
}
request("http://api.github.com") |>
req_retry(
is_transient = github_is_transient,
after = github_after
)
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.