Package retryablehttp provides a familiar HTTP client interface with automatic retries and exponential backoff.
Package httpx provides comprehensive utilities for building and executing HTTP requests with advanced features including fluent request building, automatic retry logic, and type-safe generic clients.
Package resilient provides a production-ready HTTP client with built-in rate limiting, retry with exponential backoff, and adaptive rate reduction.
Simple library for retry mechanism slightly inspired by [Try::Tiny::Retry](https://metacpan.org/pod/Try::Tiny::Retry) SYNOPSIS http get with retry: url := "http://example.com" var body []byte err := retry.Do( func() error { resp, err := http.Get(url) if err != nil { return err } defer resp.Body.Close() body, err = ioutil.ReadAll(resp.Body) if err != nil { return err } return nil }, ) fmt.Println(body) [next examples](https://github.com/avast/retry-go/tree/master/examples) SEE ALSO * [giantswarm/retry-go](https://github.com/giantswarm/retry-go) - slightly complicated interface.
Package pester provides additional resiliency over the standard http client methods by allowing you to control concurrency, retries, and a backoff strategy.
Package rehttp implements an HTTP transport that handles retries.
Package httpcontrol allows a HTTP transport supporting connection pooling, timeouts & retries.
Package retryablehttp provides a familiar HTTP client interface with automatic retries and exponential backoff.
Package cloud is the root of the packages used to access Google Cloud Services. See https://godoc.org/cloud.google.com/go for a full list of sub-packages. All clients in sub-packages are configurable via client options. These options are described here: https://godoc.org/google.golang.org/api/option. All the clients in sub-packages support authentication via Google Application Default Credentials (see https://cloud.google.com/docs/authentication/production), or by providing a JSON key file for a Service Account. See the authentication examples in this package for details. By default, all requests in sub-packages will run indefinitely, retrying on transient errors when correctness allows. To set timeouts or arrange for cancellation, use contexts. See the examples for details. Do not attempt to control the initial connection (dialing) of a service by setting a timeout on the context passed to NewClient. Dialing is non-blocking, so timeouts would be ineffective and would only interfere with credential refreshing, which uses the same context. Connection pooling differs in clients based on their transport. Cloud clients either rely on HTTP or gRPC transports to communicate with Google Cloud. Cloud clients that use HTTP (bigquery, compute, storage, and translate) rely on the underlying HTTP transport to cache connections for later re-use. These are cached to the default http.MaxIdleConns and http.MaxIdleConnsPerHost settings in http.DefaultTransport. For gRPC clients (all others in this repo), connection pooling is configurable. Users of cloud client libraries may specify option.WithGRPCConnectionPool(n) as a client option to NewClient calls. This configures the underlying gRPC connections to be pooled and addressed in a round robin fashion. Minimal docker images like Alpine lack CA certificates. This causes RPCs to appear to hang, because gRPC retries indefinitely. See https://github.com/GoogleCloudPlatform/google-cloud-go/issues/928 for more information. To see gRPC logs, set the environment variable GRPC_GO_LOG_SEVERITY_LEVEL. See https://godoc.org/google.golang.org/grpc/grpclog for more information. For HTTP logging, set the GODEBUG environment variable to "http2debug=1" or "http2debug=2". Google Application Default Credentials is the recommended way to authorize and authenticate clients. For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. To arrange for an RPC to be canceled, use context.WithCancel. You can use a file with credentials to authenticate and authorize, such as a JSON key file associated with a Google service account. Service Account keys can be created and downloaded from https://console.developers.google.com/permissions/serviceaccounts. This example uses the Datastore client, but the same steps apply to the other client libraries underneath this package. In some cases (for instance, you don't want to store secrets on disk), you can create credentials from in-memory JSON and use the WithCredentials option. The google package in this example is at golang.org/x/oauth2/google. This example uses the PubSub client, but the same steps apply to the other client libraries underneath this package. To set a timeout for an RPC, use context.WithTimeout.
Package retryrequest is an HTTP client that retries transient failures within bounds you set: an attempt limit, an elapsed-time budget, a cap on each wait, and the caller's context deadline.
Package admin is the operations side of ubgo/workflow (list failed runs, retry, forget, clear a backlog, pause, list schedules, and the data a queue dashboard shows): a Go API, a JSON HTTP handler that is closed by default, and a threshold Monitor.
Package httpx implements composable HTTP behavior as http.RoundTripper decorators: conditional caching, compression negotiation, and safe retry with backoff.
Package gotry provides an http.RoundTripper that adds retries with backoff, Retry-After handling, retry budgets and request hedging to outbound HTTP calls.
Package httpclient composes outbound net/http requests with explicit authentication, retry, admission, caching and response-handling policies.
Package httpkit is the HTTP client plumbing a program needs once it talks to more than one site: a size-capped request, typed status and rate-limit errors, one Retry-After reader, redirect policies that keep credentials with their origin, and a Transport that sets a default User-Agent and reports every round trip.
Package httpx is a small fluent HTTP client on top of net/http, with retries, request tracing and typed response helpers.
Package goguard protects outbound HTTP calls with circuit breakers, bulkheads, timeouts and safe retries.
Package httpclient composes outbound net/http requests with explicit authentication, retry, admission, caching and response-handling policies.
Package httpclient is a resilient outbound-HTTP toolkit: transient-error classification, retries over one jittered exponential backoff loop, Retry-After parsing, status mapping, secret redaction, body helpers, custom-CA TLS transports and redirect allowlists.
Package retry provides a shared exponential- or linear-backoff policy (with symmetric, additive, or flat jitter), a context-aware retry loop with an optional per-retry hook, and HTTP Retry-After parsing.
Package http provides synchronous webhook delivery over HTTP with retry and a timestamped HMAC signature.
Package retry provides an http.RoundTripper that retries failed requests by delegating the retry loop to a generic retry.Retry instance — the contract is defined in modules/core/common/resilience/retry/ and implemented in modules/extension/common/resilience/retry/.
Package httpkit provides an HTTP client for talking to other services: TLS and mTLS configuration, retries with exponential backoff and jitter over a policy that knows which requests are safe to replay, and a hook for propagating cross-process context.
Package walletd is the first-party Go SDK for the WalletD API: contract types generated from the published OpenAPI document, one HTTP client that carries credentials, idempotency keys and retries, RFC 7807 problems decoded into errors callers can errors.Is against, and webhook signature verification.
`grpc_middleware` is a collection of gRPC middleware packages: interceptors, helpers and tools. gRPC is a fantastic RPC middleware, which sees a lot of adoption in the Golang world. However, the upstream gRPC codebase is relatively bare bones. This package, and most of its child packages provides commonly needed middleware for gRPC: client-side interceptors for retires, server-side interceptors for input validation and auth, functions for chaining said interceptors, metadata convenience methods and more. By default, gRPC doesn't allow one to have more than one interceptor either on the client nor on the server side. `grpc_middleware` provides convenient chaining methods Simple way of turning a multiple interceptors into a single interceptor. Here's an example for server chaining: These interceptors will be executed from left to right: logging, monitoring and auth. Here's an example for client side chaining: These interceptors will be executed from left to right: monitoring and then retry logic. The retry interceptor will call every interceptor that follows it whenever when a retry happens. Implementing your own interceptor is pretty trivial: there are interfaces for that. But the interesting bit exposing common data to handlers (and other middleware), similarly to HTTP Middleware design. For example, you may want to pass the identity of the caller from the auth interceptor all the way to the handling function. For example, a client side interceptor example for auth looks like: Unfortunately, it's not as easy for streaming RPCs. These have the `context.Context` embedded within the `grpc.ServerStream` object. To pass values through context, a wrapper (`WrappedServerStream`) is needed. For example:
Package middleware `middleware` is a collection of gRPC middleware packages: interceptors, helpers and tools. gRPC is a fantastic RPC middleware, which sees a lot of adoption in the Golang world. However, the upstream gRPC codebase is relatively bare bones. This package, and most of its child packages provides commonly needed middleware for gRPC: client-side interceptors for retires, server-side interceptors for input validation and auth, functions for chaining said interceptors, metadata convenience methods and more. Simple way of turning a multiple interceptors into a single interceptor. Here's an example for server chaining: These interceptors will be executed from left to right: logging, monitoring and auth. Here's an example for client side chaining: These interceptors will be executed from left to right: monitoring and then retry logic. The retry interceptor will call every interceptor that follows it whenever when a retry happens. Implementing your own interceptor is pretty trivial: there are interfaces for that. But the interesting bit exposing common data to handlers (and other middleware), similarly to HTTP Middleware design. For example, you may want to pass the identity of the caller from the auth interceptor all the way to the handling function. For example, a client side interceptor example for auth looks like: Unfortunately, it's not as easy for streaming RPCs. These have the `context.Context` embedded within the `grpc.ServerStream` object. To pass values through context, a wrapper (`WrappedServerStream`) is needed. For example:
Package httptry adds retry-aware HTTP requests on top of the generic github.com/nodivbyzero/try retry engine.
Package kit — семейство мелких утилит, у которых нет и не будет внешних зависимостей: ошибки со слагом и их HTTP-форма (errs, errs/httperr), идентификатор запроса (reqid), загрузка окружения (config), а также secrets, ratelimit и retry.
Package webhook delivers events to HTTP endpoints that other systems register, the way a payment provider or a source-code host tells an integrator that something happened: one signed POST per event, retried on a fixed schedule when the receiver does not answer, and given up after a bounded time so a dead endpoint never keeps a queue alive forever.
Package githubkit is a thin, composable HTTP kernel on top of google/go-github/v69: authentication, rate-limit budgeting fed from X-RateLimit-* response headers, retry with exponential backoff, typed sentinel errors, conditional ETag caching, and concurrent pagination.
Package guardflow provides validators and a retry-until-valid guard for LLM output, plus an HTTP-middleware-style decorator for wrapping any text-generating handler with one.
Package httpclient provides a resilient HTTP client with automatic retry, circuit breaking, request-ID propagation, and typed JSON helpers.
Package fasthttp provides fast HTTP server and client API. Fasthttp provides the following features: Optimized for speed. Easily handles more than 100K qps and more than 1M concurrent keep-alive connections on modern hardware. Optimized for low memory usage. Easy 'Connection: Upgrade' support via RequestCtx.Hijack. Server provides the following anti-DoS limits: The number of concurrent connections. The number of concurrent connections per client IP. The number of requests per connection. Request read timeout. Response write timeout. Maximum request header size. Maximum request body size. Maximum request execution time. Maximum keep-alive connection lifetime. Early filtering out non-GET requests. A lot of additional useful info is exposed to request handler: Server and client address. Per-request logger. Unique request id. Request start time. Connection start time. Request sequence number for the current connection. Client supports automatic retry on idempotent requests' failure. Fasthttp API is designed with the ability to extend existing client and server implementations or to write custom client and server implementations from scratch.
Package httpx provides a resilient outbound-HTTP toolkit: transient-error classification, generic typed retry (Do) and a bounded-bytes GET (GetBytes) over one jittered-exponential-backoff loop, a transparent retrying RoundTripper, Retry-After parsing, HTTP status mapping, secret redaction, body draining, custom-CA TLS transports, and a configurable redirect allowlist.
Package rehttp implements an HTTP transport that handles retries.
Package hretrier provides a standard HTTP retry client configuration for our service-to-service calls.
Package retryablehttp provides a familiar HTTP client interface with automatic retries and exponential backoff.
Package httpx provides a resilient outbound-HTTP toolkit: transient-error classification, generic typed retry (Do) and a bounded-bytes GET (GetBytes) over one jittered-exponential-backoff loop, a transparent retrying RoundTripper, Retry-After parsing, HTTP status mapping, secret redaction, body draining, custom-CA TLS transports, and a configurable redirect allowlist.
Package retry provides utilities for retrying operations with exponential backoff and jitter, as well as transient HTTP roundtrip retries.
Package retryresponse provides a Caddy HTTP middleware module that re-executes a request based on the response status of the downstream handler (php_server etc.).
Package httpx provides a resilient outbound-HTTP toolkit: transient-error classification, generic retry with jittered exponential backoff, Retry-After parsing, HTTP status mapping, secret redaction, body draining, custom-CA TLS transports, and a configurable redirect allowlist.
Package fetch provides a resilient HTTP client with retries, timeouts, rate limiting, and circuit breaking.
Package retry implements a provider.Provider decorator that transparently retries transient upstream failures (HTTP 5xx, 429 with Retry-After) on long-running LLM sessions.
Package httpx provides a Gin-based HTTP server with built-in middleware, a health/readiness/metrics surface, typed request helpers, a JSON client with retries and a circuit breaker, and web/callback helpers.
Package httpx provides a resilient outbound-HTTP toolkit: transient-error classification, generic retry with jittered exponential backoff, Retry-After parsing, HTTP status mapping, secret redaction, body draining, and a configurable redirect allowlist.
Package rehttp implements an HTTP transport that handles retries.
Package retryablehttp provides a simple HTTP client with automatic retries, exponential backoff, and configurable retry policies.