chore: make backoff configurable in grpc retry policy, have consistent behaviour to Java flagd provider

Signed-off-by: Alexandra Oberaigner <[email protected]>

Author: alexandraoberaigner

providers/flagd/e2e/inprocess_test.go

@@ -3,6 +3,7 @@
 package e2e
 
 import (
+	flagd "github.com/open-feature/go-sdk-contrib/providers/flagd/pkg"
 	"testing"
 
 	"github.com/open-feature/go-sdk-contrib/tests/flagd/testframework"
@@ -17,6 +18,9 @@ func TestInProcessProviderE2E(t *testing.T) {
 	runner := testframework.NewTestbedRunner(testframework.TestbedConfig{
 		ResolverType:  testframework.InProcess,
 		TestbedConfig: "default",
+		ExtraOptions: []flagd.ProviderOption{
+			flagd.WithRetryBackoffMaxMs(5000),
+		},
 	})
 	defer runner.Cleanup()
 

providers/flagd/pkg/configuration.go

@@ -49,6 +49,8 @@ const (
 	flagdOfflinePathEnvironmentVariableName           = "FLAGD_OFFLINE_FLAG_SOURCE_PATH"
 	flagdTargetUriEnvironmentVariableName             = "FLAGD_TARGET_URI"
 	flagdGracePeriodVariableName                      = "FLAGD_RETRY_GRACE_PERIOD"
+	flagdRetryBackoffMsVariableName                   = "FLAGD_RETRY_BACKOFF_MS"
+	flagdRetryBackoffMaxMsVariableName                = "FLAGD_RETRY_BACKOFF_MAX_MS"
 	flagdFatalStatusCodesVariableName                 = "FLAGD_FATAL_STATUS_CODES"
 )
 
@@ -71,8 +73,8 @@ type ProviderConfiguration struct {
 	CustomSyncProviderUri            string
 	GrpcDialOptionsOverride          []grpc.DialOption
 	RetryGracePeriod                 int
-	RetryBackoffMs					 int
-	RetryBackoffMaxMs				 int
+	RetryBackoffMs                   int
+	RetryBackoffMaxMs                int
 	FatalStatusCodes                 []string
 
 	log logr.Logger
@@ -88,6 +90,8 @@ func newDefaultConfiguration(log logr.Logger) *ProviderConfiguration {
 		Resolver:                         defaultResolver,
 		Tls:                              defaultTLS,
 		RetryGracePeriod:                 defaultGracePeriod,
+		RetryBackoffMs:                   defaultRetryBackoffMs,
+		RetryBackoffMaxMs:                defaultRetryBackoffMaxMs,
 	}
 
 	p.updateFromEnvVar()
@@ -218,6 +222,8 @@ func (cfg *ProviderConfiguration) updateFromEnvVar() {
 	}
 
 	cfg.RetryGracePeriod = getIntFromEnvVarOrDefault(flagdGracePeriodVariableName, defaultGracePeriod, cfg.log)
+	cfg.RetryBackoffMs = getIntFromEnvVarOrDefault(flagdRetryBackoffMsVariableName, defaultRetryBackoffMs, cfg.log)
+	cfg.RetryBackoffMaxMs = getIntFromEnvVarOrDefault(flagdRetryBackoffMaxMsVariableName, defaultRetryBackoffMaxMs, cfg.log)
 
 	var fatalStatusCodes string
 	if envVal := os.Getenv(flagdFatalStatusCodesVariableName); envVal != "" {

providers/flagd/pkg/provider.go

@@ -74,6 +74,8 @@ func NewProvider(opts ...ProviderOption) (*Provider, error) {
 			CustomSyncProviderUri:   provider.providerConfiguration.CustomSyncProviderUri,
 			GrpcDialOptionsOverride: provider.providerConfiguration.GrpcDialOptionsOverride,
 			RetryGracePeriod:        provider.providerConfiguration.RetryGracePeriod,
+			RetryBackOffMs:          provider.providerConfiguration.RetryBackoffMs,
+			RetryBackOffMaxMs:       provider.providerConfiguration.RetryBackoffMaxMs,
 			FatalStatusCodes:        provider.providerConfiguration.FatalStatusCodes,
 		})
 	default:

providers/flagd/pkg/service/in_process/grpc_config.go

@@ -30,8 +30,8 @@ func (g *Sync) buildRetryPolicy() string {
 				},
 				"retryPolicy": RetryPolicy{
 					MaxAttempts:          3,
-					InitialBackoff:       "1s",
-					MaxBackoff:           "5s",
+					InitialBackoff:       (time.Duration(g.RetryBackOffMs) * time.Millisecond).String(),
+					MaxBackoff:           (time.Duration(g.RetryBackOffMaxMs) * time.Millisecond).String(),
 					BackoffMultiplier:    2.0,
 					RetryableStatusCodes: []string{"UNKNOWN", "UNAVAILABLE"},
 				},

providers/flagd/pkg/service/in_process/grpc_config_test.go

@@ -1,12 +1,74 @@
 package process
 
 import (
+	"encoding/json"
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"go.uber.org/zap"
 	"google.golang.org/grpc/codes"
+	"strings"
 	"testing"
 )
 
+func TestBuildRetryPolicy(t *testing.T) {
+	g := &Sync{
+		RetryBackOffMs:    100,
+		RetryBackOffMaxMs: 500,
+	}
+
+	result := g.buildRetryPolicy()
+
+	// Unmarshal to check structure
+	var policy map[string]interface{}
+	if err := json.Unmarshal([]byte(result), &policy); err != nil {
+		t.Fatalf("Failed to unmarshal result: %v", err)
+	}
+
+	methodConfig, ok := policy["methodConfig"].([]interface{})
+	if !ok || len(methodConfig) == 0 {
+		t.Fatalf("methodConfig missing or empty")
+	}
+
+	config := methodConfig[0].(map[string]interface{})
+	retryPolicy, ok := config["retryPolicy"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("retryPolicy missing")
+	}
+
+	if retryPolicy["MaxAttempts"].(float64) != 3 {
+		t.Errorf("MaxAttempts = %v; want 3", retryPolicy["MaxAttempts"])
+	}
+	if retryPolicy["InitialBackoff"].(string) != "100ms" {
+		t.Errorf("InitialBackoff = %v; want 100ms", retryPolicy["InitialBackoff"])
+	}
+	if retryPolicy["MaxBackoff"].(string) != "500ms" {
+		t.Errorf("MaxBackoff = %v; want 500ms", retryPolicy["MaxBackoff"])
+	}
+	if retryPolicy["BackoffMultiplier"].(float64) != 2.0 {
+		t.Errorf("BackoffMultiplier = %v; want 2.0", retryPolicy["BackoffMultiplier"])
+	}
+	codes := retryPolicy["RetryableStatusCodes"].([]interface{})
+	expectedCodes := []string{"UNKNOWN", "UNAVAILABLE"}
+	for i, code := range expectedCodes {
+		if codes[i].(string) != code {
+			t.Errorf("RetryableStatusCodes[%d] = %v; want %v", i, codes[i], code)
+		}
+	}
+
+	// Also check that the result is valid JSON and contains expected substrings
+	if !strings.Contains(result, `"MaxAttempts":3`) {
+		t.Error("Result does not contain MaxAttempts")
+	}
+	if !strings.Contains(result, `"InitialBackoff":"100ms"`) {
+		t.Error("Result does not contain InitialBackoff")
+	}
+	if !strings.Contains(result, `"MaxBackoff":"500ms"`) {
+		t.Error("Result does not contain MaxBackoff")
+	}
+	if !strings.Contains(result, `"RetryableStatusCodes":["UNKNOWN","UNAVAILABLE"]`) {
+		t.Error("Result does not contain RetryableStatusCodes")
+	}
+}
+
 func TestSync_initNonRetryableStatusCodesSet(t *testing.T) {
 	tests := []struct {
 		name             string

providers/flagd/pkg/service/in_process/grpc_sync.go

@@ -38,6 +38,9 @@ type Sync struct {
 	Selector                string
 	URI                     string
 	MaxMsgSize              int
+	RetryGracePeriod        int
+	RetryBackOffMs          int
+	RetryBackOffMaxMs       int
 	FatalStatusCodes        []string
 
 	// Runtime state
@@ -191,6 +194,9 @@ func (g *Sync) Sync(ctx context.Context, dataSync chan<- sync.DataSync) error {
 				}
 			}
 
+			// Backoff before retrying
+			time.Sleep(time.Duration(g.RetryBackOffMaxMs) * time.Millisecond)
+
 			g.Logger.Warn(fmt.Sprintf("sync cycle failed: %v, retrying...", err))
 			g.sendEvent(ctx, SyncEvent{event: of.ProviderError})
 

providers/flagd/pkg/service/in_process/service_grpc_test.go

@@ -50,10 +50,12 @@ func TestInProcessProviderEvaluation(t *testing.T) {
 	}
 
 	inProcessService := NewInProcessService(Configuration{
-		Host:       host,
-		Port:       port,
-		Selector:   scope,
-		TLSEnabled: false,
+		Host:              host,
+		Port:              port,
+		Selector:          scope,
+		TLSEnabled:        false,
+		RetryBackOffMaxMs: 5000,
+		RetryBackOffMs:    1000,
 	})
 
 	// when
@@ -138,9 +140,11 @@ func TestInProcessProviderEvaluationEnvoy(t *testing.T) {
 	}
 
 	inProcessService := NewInProcessService(Configuration{
-		TargetUri: "envoy://localhost:9211/foo.service",
-		Selector:   scope,
-		TLSEnabled: false,
+		TargetUri:         "envoy://localhost:9211/foo.service",
+		Selector:          scope,
+		TLSEnabled:        false,
+		RetryBackOffMaxMs: 5000,
+		RetryBackOffMs:    1000,
 	})
 
 	// when
@@ -201,7 +205,6 @@ func TestInProcessProviderEvaluationEnvoy(t *testing.T) {
 	}
 }
 
-
 // bufferedServer - a mock grpc service backed by buffered connection
 type bufferedServer struct {
 	listener              net.Listener

tests/flagd/testframework/config_steps.go

@@ -17,8 +17,6 @@ var ignoredOptions = []string{
 	"deadlineMs",
 	"streamDeadlineMs",
 	"keepAliveTime",
-	"retryBackoffMs",
-	"retryBackoffMaxMs",
 	"offlinePollIntervalMs",
 }