feat: add retry timout

Signed-off-by: Eray Ates <eray.ates@worldline.com>

Author: rytsh

client.go

@@ -3,6 +3,7 @@ package klient
 import (
 	"context"
 	"crypto/tls"
+	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -132,9 +133,23 @@ func New(opts ...OptionClientFn) (*Client, error) {
 				Transport: &http2.Transport{
 					AllowHTTP: true,
 					DialTLSContext: func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) {
-						return net.Dial(network, addr)
+						var dialer net.Dialer
+
+						conn, err := dialer.DialContext(ctx, network, addr)
+						if err != nil {
+							return nil, err
+						}
+						// If TLS config is provided, wrap the connection
+						if cfg != nil {
+							return tls.Client(conn, cfg), nil
+						}
+
+						return conn, nil
 					},
-					IdleConnTimeout: 90 * time.Second,
+					IdleConnTimeout:            90 * time.Second,
+					ReadIdleTimeout:            30 * time.Second,
+					PingTimeout:                15 * time.Second,
+					StrictMaxConcurrentStreams: true,
 				},
 			}
 		case o.PooledClient:
@@ -225,6 +240,16 @@ func New(opts ...OptionClientFn) (*Client, error) {
 	}
 
 	if !o.DisableRetry {
+		// Wrap the transport with retry timeout BEFORE creating the retry client
+		// This ensures each attempt gets its own timeout
+		if o.RetryTimeout > 0 {
+			baseTransport := client.Transport
+			client.Transport = &retryTimeoutTransport{
+				base:    baseTransport,
+				timeout: o.RetryTimeout,
+			}
+		}
+
 		// create retry client
 		retryClient := retryablehttp.Client{
 			HTTPClient:   client,
@@ -237,6 +262,25 @@ func New(opts ...OptionClientFn) (*Client, error) {
 			ErrorHandler: PassthroughErrorHandler,
 		}
 
+		// If RetryTimeout is set, wrap the check retry to allow retry on timeout
+		if o.RetryTimeout > 0 {
+			originalCheckRetry := retryClient.CheckRetry
+			retryClient.CheckRetry = func(ctx context.Context, resp *http.Response, err error) (bool, error) {
+				// If there's a context deadline exceeded error but the parent context is still valid,
+				// it means the timeout came from our per-request timeout, so we should retry
+				if err != nil && ctx.Err() == nil {
+					// Check if the error is a timeout/deadline error
+					if isTimeoutError(err) {
+						// Allow retry on timeout
+						return true, nil
+					}
+				}
+
+				// Otherwise use the original retry policy
+				return originalCheckRetry(ctx, resp, err)
+			}
+		}
+
 		client = retryClient.StandardClient()
 	}
 
@@ -282,3 +326,23 @@ func New(opts ...OptionClientFn) (*Client, error) {
 		HTTP: client,
 	}, nil
 }
+
+// isTimeoutError checks if an error is a timeout or deadline exceeded error.
+func isTimeoutError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	// Check for context deadline exceeded
+	if errors.Is(err, context.DeadlineExceeded) {
+		return true
+	}
+
+	// Check for net.Error with Timeout() == true
+	var netErr net.Error
+	if errors.As(err, &netErr) && netErr.Timeout() {
+		return true
+	}
+
+	return false
+}

config.go

@@ -16,6 +16,9 @@ type Config struct {
 	RetryMax     int           `cfg:"retry_max"`
 	RetryWaitMin time.Duration `cfg:"retry_wait_min"`
 	RetryWaitMax time.Duration `cfg:"retry_wait_max"`
+	RetryTimeout time.Duration `cfg:"retry_timeout"`
+
+	PooledClient *bool `cfg:"pooled_client"`
 
 	Proxy string `cfg:"proxy"`
 	HTTP2 *bool  `cfg:"http2"`
@@ -61,6 +64,14 @@ func (c Config) ToOption() OptionClientFn {
 			o.RetryWaitMax = c.RetryWaitMax
 		}
 
+		if c.RetryTimeout != 0 {
+			o.RetryTimeout = c.RetryTimeout
+		}
+
+		if c.PooledClient != nil {
+			o.PooledClient = *c.PooledClient
+		}
+
 		if len(c.Header) > 0 {
 			o.Header = c.Header
 		}

example_test.go

@@ -7,6 +7,9 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+	"time"
 
 	"github.com/worldline-go/klient"
 )
@@ -123,3 +126,141 @@ func Example() {
 	// Output:
 	// 123+
 }
+
+func ExampleWithRetryTimeout() {
+	// Create a client with retry timeout of 2 seconds per attempt
+	client, err := klient.New(
+		klient.WithDisableBaseURLCheck(true),
+		klient.WithRetryMax(3), // Will retry up to 3 times
+		klient.WithRetryWaitMin(500*time.Millisecond),
+		klient.WithRetryWaitMax(1*time.Second),
+		klient.WithRetryTimeout(2*time.Second), // Each attempt times out after 2 seconds
+	)
+	if err != nil {
+		panic(err)
+	}
+
+	// If a request takes longer than 2 seconds, it will timeout and retry
+	// Total possible time: ~2s (first attempt) + 0.5s (wait) + 2s (retry) + ...
+	_ = client
+	fmt.Println("Client created with 2 second timeout per retry attempt")
+	// Output: Client created with 2 second timeout per retry attempt
+}
+
+func TestRetryTimeout(t *testing.T) {
+	var attemptCount atomic.Int32
+
+	// Create a server that delays responses
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempt := attemptCount.Add(1)
+		t.Logf("Attempt %d received", attempt)
+
+		// First 2 attempts take too long (will timeout)
+		// Third attempt is fast (will succeed)
+		if attempt < 3 {
+			time.Sleep(3 * time.Second) // Longer than RetryTimeout
+		}
+
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("success"))
+	}))
+	defer server.Close()
+
+	// Create client with retry timeout
+	client, err := klient.New(
+		klient.WithDisableBaseURLCheck(true),
+		klient.WithRetryMax(3),
+		klient.WithRetryWaitMin(100*time.Millisecond),
+		klient.WithRetryWaitMax(200*time.Millisecond),
+		klient.WithRetryTimeout(2*time.Second), // Each attempt times out after 2 seconds
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, server.URL, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	start := time.Now()
+	resp, err := client.HTTP.Do(req)
+	elapsed := time.Since(start)
+
+	if err != nil {
+		t.Fatalf("Request failed after %v: %v", elapsed, err)
+	}
+	defer resp.Body.Close()
+
+	attempts := attemptCount.Load()
+	t.Logf("Request completed in %v with %d attempts", elapsed, attempts)
+
+	// Should have made 3 attempts (2 timeouts + 1 success)
+	if attempts != 3 {
+		t.Errorf("Expected 3 attempts, got %d", attempts)
+	}
+
+	// Total time should be approximately:
+	// 2s (timeout) + 0.1-0.2s (wait) + 2s (timeout) + 0.1-0.2s (wait) + <1s (success)
+	// = approximately 4-5 seconds
+	if elapsed < 4*time.Second || elapsed > 6*time.Second {
+		t.Logf("Warning: elapsed time %v outside expected range (4-6s)", elapsed)
+	}
+}
+
+func TestRetryTimeoutAllAttemptsTimeout(t *testing.T) {
+	var attemptCount atomic.Int32
+
+	// Create a server that always delays
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		attempt := attemptCount.Add(1)
+		t.Logf("Attempt %d received", attempt)
+		time.Sleep(5 * time.Second) // Always too slow
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	client, err := klient.New(
+		klient.WithDisableBaseURLCheck(true),
+		klient.WithRetryMax(2), // Will try 3 times total (initial + 2 retries)
+		klient.WithRetryWaitMin(100*time.Millisecond),
+		klient.WithRetryWaitMax(200*time.Millisecond),
+		klient.WithRetryTimeout(1*time.Second), // Each attempt times out after 1 second
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, server.URL, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	start := time.Now()
+	resp, err := client.HTTP.Do(req)
+	elapsed := time.Since(start)
+
+	if resp != nil {
+		resp.Body.Close()
+	}
+
+	attempts := attemptCount.Load()
+	t.Logf("Request failed after %v with %d attempts (error: %v)", elapsed, attempts, err)
+
+	// Should have made 3 attempts (all timeouts)
+	if attempts != 3 {
+		t.Errorf("Expected 3 attempts, got %d", attempts)
+	}
+
+	// Should have an error (context deadline exceeded)
+	if err == nil {
+		t.Error("Expected error due to timeouts, got nil")
+	}
+
+	// Total time should be approximately:
+	// 1s (timeout) + 0.1-0.2s (wait) + 1s (timeout) + 0.1-0.2s (wait) + 1s (timeout)
+	// = approximately 3-4 seconds
+	if elapsed < 3*time.Second || elapsed > 4*time.Second {
+		t.Logf("Warning: elapsed time %v outside expected range (3-4s)", elapsed)
+	}
+}

option.go

@@ -60,6 +60,10 @@ type optionClientValue struct {
 	Backoff retryablehttp.Backoff
 	// RetryLog is the flag to enable retry log of the http body. Default is true.
 	RetryLog bool
+	// RetryTimeout is the timeout for each individual retry attempt.
+	// If a single request attempt exceeds this duration, it will be canceled
+	// and the retry logic will attempt the request again (up to RetryMax times).
+	RetryTimeout time.Duration
 	// OptionRetryFns is the retry options for default retry policy.
 	OptionRetryFns []OptionRetryFn
 	// DisableEnvValues is the flag to disable all env values check.
@@ -245,6 +249,18 @@ func WithRetryPolicy(retryPolicy retryablehttp.CheckRetry) OptionClientFn {
 	}
 }
 
+// WithRetryTimeout sets the timeout for each individual retry attempt.
+// If a single request takes longer than this duration, it will be canceled
+// and trigger a retry (up to RetryMax times).
+//
+// Example: WithRetryTimeout(2*time.Second) means each attempt will timeout
+// after 2 seconds, and the request will be retried if it hasn't succeeded yet.
+func WithRetryTimeout(retryTimeout time.Duration) OptionClientFn {
+	return func(options *optionClientValue) {
+		options.RetryTimeout = retryTimeout
+	}
+}
+
 // WithRetryLog configures the client to use the provided retry log flag, default is true.
 //
 // This option is only used with default retry policy.

transport.go

@@ -2,9 +2,11 @@ package klient
 
 import (
 	"context"
+	"fmt"
 	"maps"
 	"net/http"
 	"net/url"
+	"time"
 )
 
 // TransportKlient is an http.RoundTripper that
@@ -91,3 +93,32 @@ func cloneRequest(r *http.Request) *http.Request {
 
 	return r2
 }
+
+// retryTimeoutTransport wraps an http.RoundTripper to add a timeout to each request attempt.
+// This is used to implement per-attempt timeouts for retry logic.
+type retryTimeoutTransport struct {
+	base    http.RoundTripper
+	timeout time.Duration
+}
+
+var _ http.RoundTripper = (*retryTimeoutTransport)(nil)
+
+// RoundTrip implements http.RoundTripper and adds a timeout context to each request.
+func (t *retryTimeoutTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	// Create a timeout context for this specific attempt
+	ctx, cancel := context.WithTimeout(req.Context(), t.timeout)
+	defer cancel()
+
+	// Clone the request with the timeout context
+	req2 := req.Clone(ctx)
+
+	resp, err := t.base.RoundTrip(req2)
+	if err != nil {
+		if req.Context().Err() == nil && isTimeoutError(err) {
+			// If the parent context is still valid, return a context deadline exceeded error
+			return resp, fmt.Errorf("retry timeout; %w", err)
+		}
+	}
+
+	return resp, err
+}