feat(confighttp): add max_redirects configuration option

.chloggen/add_max_redirects_confighttp.yaml

@@ -0,0 +1,25 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: 'enhancement'
+
+# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver)
+component: confighttp
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Add the max_redirects configuration option
+
+# One or more tracking issues or pull requests related to the change
+issues: [10870]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: []

config/confighttp/README.md

@@ -36,6 +36,7 @@ README](../configtls/README.md).
 - [`http2_ping_timeout`](https://pkg.go.dev/golang.org/x/net/http2#Transport)
 - [`cookies`](https://pkg.go.dev/net/http#CookieJar)
   - [`enabled`] if enabled, the client will store cookies from server responses and reuse them in subsequent requests.
+- `max_redirects`: Maximum number of redirections to follow, if not defined, the [Client uses its default policy](https://pkg.go.dev/net/http#Client), which is to stop after 10 consecutive requests.
 
 Example:
 
@@ -55,6 +56,7 @@ exporter:
     compression: zstd
     cookies:
       enabled: true
+    max_redirects: 5
 ```
 
 ## Server Configuration

config/confighttp/confighttp.go

@@ -105,6 +105,9 @@ type ClientConfig struct {
 	HTTP2PingTimeout time.Duration `mapstructure:"http2_ping_timeout"`
 	// Cookies configures the cookie management of the HTTP client.
 	Cookies *CookiesConfig `mapstructure:"cookies"`
+
+	// Maximum number of redirections to follow, if not defined, the Client uses its default policy, which is to stop after 10 consecutive requests.
+	MaxRedirects *int `mapstructure:"max_redirects"`
 }
 
 // CookiesConfig defines the configuration of the HTTP client regarding cookies served by the server.
@@ -242,12 +245,27 @@ func (hcs *ClientConfig) ToClient(ctx context.Context, host component.Host, sett
 	}
 
 	return &http.Client{
-		Transport: clientTransport,
-		Timeout:   hcs.Timeout,
-		Jar:       jar,
+		CheckRedirect: makeCheckRedirect(hcs.MaxRedirects),
+		Transport:     clientTransport,
+		Timeout:       hcs.Timeout,
+		Jar:           jar,
 	}, nil
 }
 
+// makeCheckRedirect checks if max redirects are exceeded
+func makeCheckRedirect(max *int) func(*http.Request, []*http.Request) error {
+	if max == nil {
+		return nil
+	}
+
+	return func(_ *http.Request, via []*http.Request) error {
+		if len(via) > *max {
+			return http.ErrUseLastResponse
+		}
+		return nil
+	}
+}
+
 // Custom RoundTripper that adds headers.
 type headerRoundTripper struct {
 	transport http.RoundTripper

config/confighttp/confighttp_test.go

@@ -336,6 +336,97 @@ func TestHTTPClientSettingsError(t *testing.T) {
 	}
 }
 
+func TestMaxRedirects(t *testing.T) {
+	toIntPtr := func(i int) *int {
+		return &i
+	}
+	tests := []struct {
+		name             string
+		settings         ClientConfig
+		expectedRequests int
+		expectedErrStr   string
+	}{
+		{
+			name:             "No redirects config",
+			settings:         ClientConfig{},
+			expectedRequests: 10,
+			// default client returns an error, custom implementations should return a ErrUseLastResponse which the internal http package will skip it to let the users select the previous response without closing the body.
+			expectedErrStr: "stopped after 10 redirects",
+		},
+		{
+			name:             "Zero redirects",
+			settings:         ClientConfig{MaxRedirects: toIntPtr(0)},
+			expectedRequests: 1,
+		},
+		{
+			name:             "One redirect",
+			settings:         ClientConfig{MaxRedirects: toIntPtr(1)},
+			expectedRequests: 2,
+		},
+		{
+			name:             "Defined max redirects",
+			settings:         ClientConfig{MaxRedirects: toIntPtr(5)},
+			expectedRequests: 6,
+		},
+	}
+
+	countRequests := func(resp *http.Response) int {
+		counter := 0
+		for resp != nil {
+			resp = resp.Request.Response
+			counter++
+		}
+		return counter
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			client, err := test.settings.ToClient(context.Background(), componenttest.NewNopHost(), componenttest.NewNopTelemetrySettings())
+			require.NoError(t, err)
+
+			hss := &ServerConfig{
+				Endpoint: "localhost:0",
+			}
+
+			ln, err := hss.ToListener(context.Background())
+			require.NoError(t, err)
+
+			url := fmt.Sprintf("http://%s", ln.Addr().String())
+
+			// always return a redirection to itself
+			s, err := hss.ToServer(
+				context.Background(),
+				componenttest.NewNopHost(),
+				componenttest.NewNopTelemetrySettings(),
+				http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+					http.Redirect(w, r, url, http.StatusMovedPermanently)
+				}))
+			require.NoError(t, err)
+
+			go func() {
+				_ = s.Serve(ln)
+			}()
+
+			req, err := http.NewRequest(http.MethodOptions, url, nil)
+			require.NoError(t, err)
+			resp, err := client.Do(req)
+
+			if test.expectedErrStr != "" {
+				require.ErrorContains(t, err, test.expectedErrStr)
+			} else {
+				require.NoError(t, err)
+			}
+			assert.Equal(t, http.StatusMovedPermanently, resp.StatusCode)
+
+			defer resp.Body.Close()
+
+			require.Equal(t, test.expectedRequests, countRequests(resp))
+
+			require.NoError(t, s.Close())
+		})
+	}
+}
+
 func TestHTTPClientSettingWithAuthConfig(t *testing.T) {
 	tests := []struct {
 		name      string