Fix request body handling in DoExponentialBackoff

Previously, DoExponentialBackoff relied on Seek to reset request bodies
between retries. This approach failed when bodies didn't implement Seek
or when req.GetBody wasn't set (e.g., manually wrapped io.NopCloser),
causing "ContentLength=N with Body length 0" errors on retry attempts.

The issue occurred because req.Clone() reuses the exhausted body reader
without resetting it, leading to empty bodies on subsequent attempts
while ContentLength remained set from the original request.

Now read the entire request body upfront and create fresh io.Readers
for each retry attempt. This ensures:
- Body is always available for all retry attempts
- ContentLength is correctly set to match the actual body
- Works reliably with all io.Reader types, not just seekable ones

Added test case with io.NopCloser-wrapped bytes.Buffer that validates
both body content and ContentLength matching across retry attempts.

Author: rafaeljusto

httputilx/httputilx.go

@@ -232,15 +232,27 @@ func DoExponentialBackoff(req *http.Request, options ...ExponentialBackoffOption
 
 	backoff := o.initialBackoff
 
+	// Read the request body once if it exists, so we can replay it on retries.
+	// This is necessary because some body types (like manually wrapped
+	// io.NopCloser) don't have GetBody set, causing "ContentLength=N with Body
+	// length 0" errors when req.Clone() tries to reuse the exhausted body.
+	var bodyBytes []byte
+	if req.Body != nil {
+		var err error
+		bodyBytes, err = io.ReadAll(req.Body)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to read request body")
+		}
+		if err := req.Body.Close(); err != nil {
+			return nil, errors.Wrap(err, "failed to close request body")
+		}
+	}
+
 	for attempt := 0; attempt <= o.maxRetries; attempt++ {
 		reqClone := req.Clone(req.Context())
-		if req.Body != nil {
-			if seeker, ok := req.Body.(interface {
-				Seek(int64, int) (int64, error)
-			}); ok {
-				_, _ = seeker.Seek(0, 0)
-			}
-			reqClone.Body = req.Body
+		if bodyBytes != nil {
+			reqClone.Body = io.NopCloser(bytes.NewReader(bodyBytes))
+			reqClone.ContentLength = int64(len(bodyBytes))
 		}
 
 		resp, err := o.client.Do(reqClone)

httputilx/httputilx_test.go

@@ -230,6 +230,7 @@ func TestDoExponentialBackoff(t *testing.T) {
 		name         string
 		options      []ExponentialBackoffOption
 		handler      http.HandlerFunc
+		requestBody  io.Reader
 		wantBody     string
 		wantErr      string
 		wantAttempts int
@@ -323,6 +324,55 @@ func TestDoExponentialBackoff(t *testing.T) {
 			wantErr:      "",
 			wantAttempts: 3,
 		},
+		{
+			name: "RequestBodyCopiedOnRetry",
+			options: []ExponentialBackoffOption{
+				ExponentialBackoffWithConfig(4, 100*time.Millisecond, 5*time.Second, 2.0),
+			},
+			handler: func() http.HandlerFunc {
+				initialBody := "request body content"
+
+				attempts := 0
+				return func(w http.ResponseWriter, r *http.Request) {
+					attempts++
+
+					if r.ContentLength != int64(len(initialBody)) {
+						w.WriteHeader(http.StatusInternalServerError)
+						_, _ = fmt.Fprintf(w, "wrong content-length: got %d, want %d", r.ContentLength, len(initialBody))
+						return
+					}
+
+					body, err := io.ReadAll(r.Body)
+					if err != nil {
+						w.WriteHeader(http.StatusInternalServerError)
+						return
+					}
+
+					if len(body) != len(initialBody) {
+						w.WriteHeader(http.StatusInternalServerError)
+						_, _ = fmt.Fprintf(w, "content-length mismatch: header=%d actual=%d", r.ContentLength, len(body))
+						return
+					}
+
+					// Verify body is correctly sent on all attempts
+					if string(body) != initialBody {
+						w.WriteHeader(http.StatusInternalServerError)
+						_, _ = fmt.Fprintf(w, "incorrect body: %q", string(body))
+						return
+					}
+					if attempts < 3 {
+						w.WriteHeader(http.StatusInternalServerError)
+						return
+					}
+					w.WriteHeader(http.StatusOK)
+					_, _ = w.Write([]byte("body received correctly"))
+				}
+			}(),
+			requestBody:  io.NopCloser(bytes.NewBuffer([]byte("request body content"))),
+			wantBody:     "body received correctly",
+			wantErr:      "",
+			wantAttempts: 3,
+		},
 	}
 
 	for _, tt := range tests {
@@ -334,7 +384,7 @@ func TestDoExponentialBackoff(t *testing.T) {
 			}))
 			defer ts.Close()
 
-			req, err := http.NewRequest(http.MethodGet, ts.URL, nil)
+			req, err := http.NewRequest(http.MethodGet, ts.URL, tt.requestBody)
 			if err != nil {
 				t.Fatalf("failed to create request: %v", err)
 			}