chore(deps): pin delivery backoff max branch

Signed-off-by: kahirokunn <okinakahiro@gmail.com>

Author: kahirokunn

go.mod

@@ -130,3 +130,5 @@ require (
 	sigs.k8s.io/randfill v1.0.0 // indirect
 	sigs.k8s.io/structured-merge-diff/v6 v6.3.0 // indirect
 )
+
+replace knative.dev/eventing => github.com/kahirokunn/knative-eventing v0.0.0-20260821080516-828cffcff320

go.sum

@@ -320,6 +320,8 @@ github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHm
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kahirokunn/knative-eventing v0.0.0-20260821080516-828cffcff320 h1:vdKDX5EHiufGVgmzdIyqS6KFW82/Oxw3zW74XM4Qig0=
+github.com/kahirokunn/knative-eventing v0.0.0-20260821080516-828cffcff320/go.mod h1:HC1K7A1oa/sMd6X6RHO547NgvL2gtKlmNK+HYnELz6g=
 github.com/kelseyhightower/envconfig v1.4.0 h1:Im6hONhd3pLkfDFsbRgu68RDNkGF1r3dvMUtDTo2cv8=
 github.com/kelseyhightower/envconfig v1.4.0/go.mod h1:cccZRl6mQpaq41TPp5QxidR+Sa3axMbJDNb//FQX6Gg=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
@@ -1074,8 +1076,6 @@ k8s.io/kube-openapi v0.0.0-20250910181357-589584f1c912 h1:Y3gxNAuB0OBLImH611+UDZ
 k8s.io/kube-openapi v0.0.0-20250910181357-589584f1c912/go.mod h1:kdmbQkyfwUagLfXIad1y2TdrjPFWp2Q89B3qkRwf/pQ=
 k8s.io/utils v0.0.0-20251002143259-bc988d571ff4 h1:SjGebBtkBqHFOli+05xYbK8YF1Dzkbzn+gDM4X9T4Ck=
 k8s.io/utils v0.0.0-20251002143259-bc988d571ff4/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
-knative.dev/eventing v0.50.1-0.20260820115420-72ec4f420db1 h1:N61jbMWe2eUDVBnXP2beXD0OmUGSxb75NTfhAtBeS8o=
-knative.dev/eventing v0.50.1-0.20260820115420-72ec4f420db1/go.mod h1:HC1K7A1oa/sMd6X6RHO547NgvL2gtKlmNK+HYnELz6g=
 knative.dev/hack v0.0.0-20260428014158-b2a37f1b6e7b h1:MvbV2F2BdI8qKrYYUhDwbUZbX0BAYRSIpXM2TOtTvs0=
 knative.dev/hack v0.0.0-20260428014158-b2a37f1b6e7b/go.mod h1:L5RzHgbvam0u8QFHfzCX6MKxu/a/gIGEdaRBqNiVbl0=
 knative.dev/pkg v0.0.0-20260820190123-c9015f8bfdea h1:vNg/ixrFn2UMDAh727Ag26G3jZAQGskbn5VOwZvKoOM=

vendor/knative.dev/eventing/pkg/apis/duck/v1/delivery_types.go

@@ -62,6 +62,22 @@ type DeliverySpec struct {
 	// +optional
 	BackoffDelay *string `json:"backoffDelay,omitempty"`
 
+	// BackoffMax is the maximum delay between normal delivery attempts. It caps
+	// the delay calculated from BackoffDelay and BackoffPolicy, but does not cap
+	// delays requested by a Retry-After response header. The value must be
+	// greater than zero.
+	//
+	// Note: This API is EXPERIMENTAL and might be changed at any time. Cluster
+	// operators must enable the delivery-backoff-max feature before users can set
+	// this field.
+	//
+	// More information on Duration format:
+	//  - https://www.iso.org/iso-8601-date-and-time-format.html
+	//  - https://en.wikipedia.org/wiki/ISO_8601
+	//
+	// +optional
+	BackoffMax *string `json:"backoffMax,omitempty"`
+
 	// RetryAfterMax provides an optional upper bound on the duration specified in a "Retry-After" header
 	// when calculating backoff times for retrying 429 and 503 response codes.  Setting the value to
 	// zero ("PT0S") can be used to opt-out of respecting "Retry-After" header values altogether. This
@@ -131,6 +147,17 @@ func (ds *DeliverySpec) Validate(ctx context.Context) *apis.FieldError {
 		}
 	}
 
+	if ds.BackoffMax != nil {
+		if feature.FromContext(ctx).IsEnabled(feature.DeliveryBackoffMax) {
+			p, pe := period.Parse(*ds.BackoffMax)
+			if pe != nil || p.IsZero() || p.IsNegative() {
+				errs = errs.Also(apis.ErrInvalidValue(*ds.BackoffMax, "backoffMax"))
+			}
+		} else {
+			errs = errs.Also(apis.ErrDisallowedFields("backoffMax"))
+		}
+	}
+
 	if ds.Format != nil {
 		switch *ds.Format {
 		case DeliveryFormatBinary, DeliveryFormatJson:

vendor/knative.dev/eventing/pkg/apis/duck/v1/zz_generated.deepcopy.go

@@ -81,6 +81,7 @@ func newDefaults() Flags {
 	return map[string]Flag{
 		KReferenceGroup:            Disabled,
 		DeliveryRetryAfter:         Disabled,
+		DeliveryBackoffMax:         Disabled,
 		DeliveryTimeout:            Enabled,
 		KReferenceMapping:          Disabled,
 		TransportEncryption:        Disabled,

vendor/knative.dev/eventing/pkg/apis/feature/features.go

@@ -19,6 +19,7 @@ package feature
 const (
 	KReferenceGroup            = "kreference-group"
 	DeliveryRetryAfter         = "delivery-retryafter"
+	DeliveryBackoffMax         = "delivery-backoff-max"
 	DeliveryTimeout            = "delivery-timeout"
 	KReferenceMapping          = "kreference-mapping"
 	TransportEncryption        = "transport-encryption"

vendor/knative.dev/eventing/pkg/apis/feature/flag_names.go

@@ -19,7 +19,6 @@ package kncloudevents
 import (
 	"context"
 	"fmt"
-	"math"
 	"net/http"
 	"strconv"
 	"time"
@@ -58,11 +57,12 @@ type Backoff func(attemptNum int, resp *http.Response) time.Duration
 type RetryConfig struct {
 	// Maximum number of retries
 	RetryMax int
-	// These next two variables are just copied from the original DeliverySpec so
+	// These next three variables are just copied from the original DeliverySpec so
 	// we can detect if anything has changed. We can not do that with the CheckRetry
 	// Backoff (at least not easily).
 	BackoffDelay  *string
 	BackoffPolicy *v1.BackoffPolicyType
+	BackoffMax    *string
 
 	CheckRetry CheckRetry
 	Backoff    Backoff
@@ -92,6 +92,20 @@ func RetryConfigFromDeliverySpec(spec v1.DeliverySpec) (RetryConfig, error) {
 	}
 	retryConfig.BackoffPolicy = spec.BackoffPolicy
 	retryConfig.BackoffDelay = spec.BackoffDelay
+	retryConfig.BackoffMax = spec.BackoffMax
+
+	var backoffMaxDuration *time.Duration
+	if spec.BackoffMax != nil {
+		maxPeriod, err := period.Parse(*spec.BackoffMax)
+		if err != nil || maxPeriod.IsZero() || maxPeriod.IsNegative() {
+			if err != nil {
+				return retryConfig, fmt.Errorf("failed to parse Spec.BackoffMax: %w", err)
+			}
+			return retryConfig, fmt.Errorf("Spec.BackoffMax must be greater than zero")
+		}
+		maxDelay := saturatingPeriodDuration(maxPeriod)
+		backoffMaxDuration = &maxDelay
+	}
 
 	if spec.BackoffPolicy != nil && spec.BackoffDelay != nil {
 
@@ -100,15 +114,15 @@ func RetryConfigFromDeliverySpec(spec v1.DeliverySpec) (RetryConfig, error) {
 			return retryConfig, fmt.Errorf("failed to parse Spec.BackoffDelay: %w", err)
 		}
 
-		delayDuration, _ := delay.Duration()
+		delayDuration := saturatingPeriodDuration(delay)
 		switch *spec.BackoffPolicy {
 		case v1.BackoffPolicyExponential:
 			retryConfig.Backoff = func(attemptNum int, resp *http.Response) time.Duration {
-				return delayDuration * time.Duration(math.Exp2(float64(attemptNum)))
+				return exponentialBackoff(delayDuration, attemptNum, backoffMaxDuration)
 			}
 		case v1.BackoffPolicyLinear:
 			retryConfig.Backoff = func(attemptNum int, resp *http.Response) time.Duration {
-				return delayDuration * time.Duration(attemptNum)
+				return linearBackoff(delayDuration, attemptNum, backoffMaxDuration)
 			}
 		}
 	}
@@ -133,6 +147,55 @@ func RetryConfigFromDeliverySpec(spec v1.DeliverySpec) (RetryConfig, error) {
 	return retryConfig, nil
 }
 
+const maxBackoffDuration = time.Duration(1<<63 - 1)
+
+func saturatingPeriodDuration(p period.Period) time.Duration {
+	if p.IsPositive() && p.TotalDaysApprox() > int(maxBackoffDuration/(24*time.Hour)) {
+		return maxBackoffDuration
+	}
+
+	d, _ := p.Duration()
+	if p.IsPositive() && d < 0 {
+		return maxBackoffDuration
+	}
+	return d
+}
+
+func linearBackoff(delay time.Duration, attemptNum int, configuredMax *time.Duration) time.Duration {
+	if attemptNum <= 0 || delay <= 0 {
+		return 0
+	}
+	limit := maxBackoffDuration
+	if configuredMax != nil {
+		limit = *configuredMax
+	}
+	if delay >= limit || time.Duration(attemptNum) > limit/delay {
+		return limit
+	}
+	return delay * time.Duration(attemptNum)
+}
+
+func exponentialBackoff(delay time.Duration, attemptNum int, configuredMax *time.Duration) time.Duration {
+	if attemptNum < 0 || delay <= 0 {
+		return 0
+	}
+	limit := maxBackoffDuration
+	if configuredMax != nil {
+		limit = *configuredMax
+	}
+	if delay >= limit {
+		return limit
+	}
+	result := delay
+	for range attemptNum {
+		if result > limit/2 {
+			return limit
+		}
+		result *= 2
+	}
+	return result
+}
+
 // SelectiveRetry is an alternative function to determine whether to retry based on response
 //
 // Note - Returning true indicates a retry should occur.  Returning an error will result in that

vendor/knative.dev/eventing/pkg/kncloudevents/retries.go

@@ -1212,7 +1212,7 @@ k8s.io/utils/net
 k8s.io/utils/pointer
 k8s.io/utils/ptr
 k8s.io/utils/trace
-# knative.dev/eventing v0.50.1-0.20260820115420-72ec4f420db1
+# knative.dev/eventing v0.50.1-0.20260820115420-72ec4f420db1 => github.com/kahirokunn/knative-eventing v0.0.0-20260821080516-828cffcff320
 ## explicit; go 1.25.0
 knative.dev/eventing/pkg/apis
 knative.dev/eventing/pkg/apis/common/integration/v1alpha1
@@ -1460,3 +1460,4 @@ sigs.k8s.io/structured-merge-diff/v6/value
 # sigs.k8s.io/yaml v1.6.0
 ## explicit; go 1.22
 sigs.k8s.io/yaml
+# knative.dev/eventing => github.com/kahirokunn/knative-eventing v0.0.0-20260821080516-828cffcff320