fix: decouple connection retry backoff from TCP dial timeout

KEDA_HTTP_CONNECT_TIMEOUT was incorrectly used as both the TCP dial
timeout and the initial retry backoff duration. This caused cold start
response times to scale linearly with the timeout value (e.g., 500ms
timeout → 3.5s response, 5s timeout → 7.8s response).

Changes:
- Use fixed 50ms initial backoff duration for cold start polling
- Adopt Knatives proven backoff strategy (factor 1.4, jitter 0.1)
- Fix MinTotalBackoffDuration to calculate exponential (not linear) sum
- Improve dial retry test coverage

Signed-off-by: Vincent Link <vlink@redhat.com>

Author: linkvt

CHANGELOG.md

@@ -35,7 +35,7 @@ This changelog keeps track of work items that have been completed and are ready
 
 ### Fixes
 
-- **General**: TODO ([#TODO](https://github.com/kedacore/http-add-on/issues/TODO))
+- **Interceptor**: Decouple connection retry backoff from TCP dial timeout for faster cold starts ([#1385](https://github.com/kedacore/http-add-on/issues/1385))
 
 ### Deprecations
 

interceptor/config/timeouts.go

@@ -36,22 +36,18 @@ type Timeouts struct {
 	ExpectContinueTimeout time.Duration `envconfig:"KEDA_HTTP_EXPECT_CONTINUE_TIMEOUT" default:"1s"`
 }
 
-// Backoff returns a wait.Backoff based on the timeouts in t
-func (t *Timeouts) Backoff(factor, jitter float64, steps int) wait.Backoff {
+// DefaultBackoff returns backoff config optimized for cold start pod availability polling.
+// Based on https://github.com/knative/networking/blob/main/test/conformance/ingress/util.go#L70
+func (t Timeouts) DefaultBackoff() wait.Backoff {
 	return wait.Backoff{
-		Duration: t.Connect,
-		Factor:   factor,
-		Jitter:   jitter,
-		Steps:    steps,
+		Cap:      10 * time.Second, // max sleep time per step
+		Duration: 50 * time.Millisecond,
+		Factor:   1.4,
+		Jitter:   0.1, // adds up to +10% randomness
+		Steps:    10,
 	}
 }
 
-// DefaultBackoff calls t.Backoff with reasonable defaults and returns
-// the result
-func (t Timeouts) DefaultBackoff() wait.Backoff {
-	return t.Backoff(2, 0.5, 5)
-}
-
 // Parse parses standard configs using envconfig and returns a pointer to the
 // newly created config. Returns nil and a non-nil error if parsing failed
 func MustParseTimeouts() *Timeouts {

interceptor/handler/upstream_test.go

@@ -298,8 +298,7 @@ func TestForwarderHeaderTimeout(t *testing.T) {
 	timeouts := defaultTimeouts()
 	timeouts.Connect = 1 * time.Millisecond
 	timeouts.ResponseHeader = 1 * time.Millisecond
-	backoff := timeouts.Backoff(2, 2, 1)
-	dialCtxFunc := retryDialContextFunc(timeouts, backoff)
+	dialCtxFunc := retryDialContextFunc(timeouts, timeouts.DefaultBackoff())
 	res, req, err := reqAndRes("/testfwd")
 	r.NoError(err)
 	req = util.RequestWithStream(req, originURL)
@@ -387,8 +386,7 @@ func TestForwarderConnectionRetryAndTimeout(t *testing.T) {
 	// forwardDoneSignal should close _after_ the total timeout of forwardRequest.
 	//
 	// forwardRequest uses dialCtxFunc to establish network connections, and dialCtxFunc does
-	// exponential backoff. It starts at 2ms (timeouts.Connect above), doubles every time, and stops after 5 tries,
-	// so that's 2ms + 4ms + 8ms + 16ms + 32ms, or SUM(2^N) where N is in [1, 5]
+	// exponential backoff.
 	expectedForwardTimeout := kedanet.MinTotalBackoffDuration(timeouts.DefaultBackoff())
 	r.GreaterOrEqualf(
 		elapsed,
@@ -427,8 +425,7 @@ func TestForwardRequestRedirectAndHeaders(t *testing.T) {
 	timeouts := defaultTimeouts()
 	timeouts.Connect = 10 * time.Millisecond
 	timeouts.ResponseHeader = 10 * time.Millisecond
-	backoff := timeouts.Backoff(2, 2, 1)
-	dialCtxFunc := retryDialContextFunc(timeouts, backoff)
+	dialCtxFunc := retryDialContextFunc(timeouts, timeouts.DefaultBackoff())
 	res, req, err := reqAndRes("/testfwd")
 	r.NoError(err)
 	req = util.RequestWithStream(req, srvURL)

pkg/net/backoff.go

@@ -6,14 +6,13 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 )
 
-// MinTotalBackoffDuration returns the minimum duration that backoff
-// would wait, including all steps, not including any jitter
+// MinTotalBackoffDuration returns the minimum total sleep duration across all retry steps.
 func MinTotalBackoffDuration(backoff wait.Backoff) time.Duration {
-	initial := backoff.Duration.Milliseconds()
-	retMS := backoff.Duration.Milliseconds()
-	numSteps := backoff.Steps
-	for i := 2; i <= numSteps; i++ {
-		retMS += initial * int64(i)
+	var total time.Duration
+	duration := backoff.Duration
+	for range backoff.Steps {
+		total += duration
+		duration = time.Duration(float64(duration) * backoff.Factor)
 	}
-	return time.Duration(retMS) * time.Millisecond
+	return total
 }

pkg/net/dial_context_test.go

@@ -2,44 +2,107 @@ package net
 
 import (
 	"context"
+	"net"
+	"net/http"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/util/wait"
 )
 
+// getUnreachableAddr returns an address that is guaranteed to be unreachable
+// by allocating an available port and immediately closing it
+func getUnreachableAddr(t *testing.T) string {
+	t.Helper()
+	listener, err := net.Listen("tcp", "localhost:0")
+	require.NoError(t, err)
+	addr := listener.Addr().String()
+	listener.Close()
+	return addr
+}
+
 func TestDialContextWithRetry(t *testing.T) {
-	r := require.New(t)
-
-	const (
-		connTimeout = 10 * time.Millisecond
-		keepAlive   = 10 * time.Millisecond
-		network     = "tcp"
-		addr        = "localhost:60001"
-	)
-	backoff := wait.Backoff{
-		Duration: connTimeout,
-		Factor:   2,
-		Jitter:   0.5,
-		Steps:    5,
-	}
-
-	ctx := context.Background()
-	dialer := NewNetDialer(connTimeout, keepAlive)
-	dRetry := DialContextWithRetry(dialer, backoff)
-	minTotalWaitDur := MinTotalBackoffDuration(backoff)
-
-	start := time.Now()
-	_, err := dRetry(ctx, network, addr)
-	r.Error(err, "error was not found")
-
-	elapsed := time.Since(start)
-	r.GreaterOrEqual(
-		elapsed,
-		minTotalWaitDur,
-		"total elapsed (%s) was not >= than the minimum expected (%s)",
-		elapsed,
-		minTotalWaitDur,
-	)
+	t.Run("retries with exponential backoff on connection failure", func(t *testing.T) {
+		r := require.New(t)
+
+		backoff := wait.Backoff{
+			Duration: 10 * time.Millisecond,
+			Factor:   2,
+			Jitter:   0.1,
+			Steps:    3,
+		}
+
+		dialer := NewNetDialer(5*time.Millisecond, 10*time.Millisecond)
+		dialRetry := DialContextWithRetry(dialer, backoff)
+
+		start := time.Now()
+		_, err := dialRetry(context.Background(), "tcp", getUnreachableAddr(t))
+		elapsed := time.Since(start)
+
+		r.Error(err, "should fail when connecting to unreachable address")
+
+		// Verify backoff was applied by checking we took at least the minimum backoff time
+		minExpected := MinTotalBackoffDuration(backoff)
+		r.GreaterOrEqual(elapsed, minExpected, "should take at least minimum backoff duration")
+	})
+
+	t.Run("succeeds immediately when connection available", func(t *testing.T) {
+		r := require.New(t)
+
+		backoff := wait.Backoff{
+			Duration: 50 * time.Millisecond,
+			Factor:   2,
+			Jitter:   0.1,
+			Steps:    5,
+		}
+
+		srv, srvURL, err := StartTestServer(NewTestHTTPHandlerWrapper(
+			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			}),
+		))
+		r.NoError(err)
+		defer srv.Close()
+
+		dialer := NewNetDialer(100*time.Millisecond, 1*time.Second)
+		dialRetry := DialContextWithRetry(dialer, backoff)
+
+		start := time.Now()
+		conn, err := dialRetry(context.Background(), "tcp", srvURL.Host)
+		elapsed := time.Since(start)
+
+		r.NoError(err)
+		r.NotNil(conn)
+		if conn != nil {
+			conn.Close()
+		}
+
+		r.Less(elapsed, backoff.Duration)
+	})
+
+	t.Run("respects context cancellation", func(t *testing.T) {
+		r := require.New(t)
+
+		backoff := wait.Backoff{
+			Duration: 100 * time.Millisecond,
+			Factor:   2,
+			Jitter:   0.1,
+			Steps:    5,
+		}
+
+		dialer := NewNetDialer(10*time.Millisecond, 1*time.Second)
+		dialRetry := DialContextWithRetry(dialer, backoff)
+
+		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+		defer cancel()
+
+		start := time.Now()
+		_, err := dialRetry(ctx, "tcp", getUnreachableAddr(t))
+		elapsed := time.Since(start)
+
+		r.Error(err)
+		r.Contains(err.Error(), "context")
+		r.Less(elapsed, MinTotalBackoffDuration(backoff))
+	})
 }