feat(flagd): Configure in-process provider using FLAGD_SYNC_PORT environment variable

providers/flagd/README.md

@@ -38,7 +38,7 @@ provider, err := flagd.NewProvider(flagd.WithInProcessResolver())
 openfeature.SetProvider(provider)
 ```
 
-In the above example, in-process handlers attempt to connect to a sync service on address `localhost:8013` to obtain [flag definitions](https://github.com/open-feature/schemas/blob/main/json/flagd-definitions.json).
+In the above example, in-process handlers attempt to connect to a sync service on address `localhost:8015` to obtain [flag definitions](https://github.com/open-feature/schemas/blob/main/json/flagd-definitions.json).
 
 #### Custom sync provider
 
@@ -95,7 +95,7 @@ Configuration can be provided as constructor options or as environment variables
 | Option name                                              | Environment variable name      | Type & supported value      | Default   | Compatible resolver |
 |----------------------------------------------------------|--------------------------------|-----------------------------|-----------|---------------------|
 | WithHost                                                 | FLAGD_HOST                     | string                      | localhost | rpc & in-process    |
-| WithPort                                                 | FLAGD_PORT                     | number                      | 8013      | rpc & in-process    |
+| WithPort                                                 | FLAGD_PORT (rpc), FLAGD_SYNC_PORT or FLAGD_PORT (in-process) | number | 8013 (rpc), 8015 (in-process) | rpc & in-process |
 | WithTargetUri                                            | FLAGD_TARGET_URI               | string                      | ""        | in-process          |
 | WithTLS                                                  | FLAGD_TLS                      | boolean                     | false     | rpc & in-process    |
 | WithSocketPath                                           | FLAGD_SOCKET_PATH              | string                      | ""        | rpc & in-process    |
@@ -106,6 +106,8 @@ Configuration can be provided as constructor options or as environment variables
 | WithProviderID                                           | FLAGD_SOURCE_PROVIDER_ID       | string                      | ""        | in-process          |
 | WithSelector                                             | FLAGD_SOURCE_SELECTOR          | string                      | ""        | in-process          | 
 
+> **Note:** For the in-process resolver, `FLAGD_SYNC_PORT` takes priority over `FLAGD_PORT`. The `FLAGD_PORT` environment variable is still supported for backwards compatibility. 
+
 ### Overriding behavior
 
 By default, the flagd provider will read non-empty environment variables to set its own configuration with the lowest priority.

providers/flagd/pkg/configuration.go

@@ -33,6 +33,7 @@ const (
 
 	flagdHostEnvironmentVariableName                  = "FLAGD_HOST"
 	flagdPortEnvironmentVariableName                  = "FLAGD_PORT"
+	flagdSyncPortEnvironmentVariableName              = "FLAGD_SYNC_PORT"
 	flagdTLSEnvironmentVariableName                   = "FLAGD_TLS"
 	flagdSocketPathEnvironmentVariableName            = "FLAGD_SOCKET_PATH"
 	flagdServerCertPathEnvironmentVariableName        = "FLAGD_SERVER_CERT_PATH"
@@ -130,20 +131,6 @@ func validateProviderConfiguration(p *ProviderConfiguration) error {
 
 // updateFromEnvVar is a utility to update configurations based on current environment variables
 func (cfg *ProviderConfiguration) updateFromEnvVar() {
-	portS := os.Getenv(flagdPortEnvironmentVariableName)
-	if portS != "" {
-		port, err := strconv.Atoi(portS)
-		if err != nil {
-			cfg.log.Error(err,
-				fmt.Sprintf(
-					"invalid env config for %s provided, using default value: %d or %d depending on resolver",
-					flagdPortEnvironmentVariableName, defaultRpcPort, defaultInProcessPort,
-				))
-		} else {
-			cfg.Port = uint16(port)
-		}
-	}
-
 	if host := os.Getenv(flagdHostEnvironmentVariableName); host != "" {
 		cfg.Host = host
 	}
@@ -212,6 +199,9 @@ func (cfg *ProviderConfiguration) updateFromEnvVar() {
 		}
 	}
 
+	// Parse port after resolver is known to handle FLAGD_SYNC_PORT for in-process resolver
+	cfg.updatePortFromEnvVar()
+
 	if offlinePath := os.Getenv(flagdOfflinePathEnvironmentVariableName); offlinePath != "" {
 		cfg.OfflineFlagSourcePath = offlinePath
 	}
@@ -238,6 +228,37 @@ func (cfg *ProviderConfiguration) updateFromEnvVar() {
 
 }
 
+// updatePortFromEnvVar updates the port configuration from environment variables.
+// For in-process resolver, FLAGD_SYNC_PORT takes priority over FLAGD_PORT (backwards compatibility).
+// For rpc resolver, only FLAGD_PORT is used.
+func (cfg *ProviderConfiguration) updatePortFromEnvVar() {
+	var portS string
+	var envVarName string
+
+	if cfg.Resolver == inProcess {
+		portS = os.Getenv(flagdSyncPortEnvironmentVariableName)
+		envVarName = flagdSyncPortEnvironmentVariableName
+	}
+
+	if portS == "" {
+		portS = os.Getenv(flagdPortEnvironmentVariableName)
+		envVarName = flagdPortEnvironmentVariableName
+	}
+
+	if portS != "" {
+		port, err := strconv.Atoi(portS)
+		if err != nil {
+			cfg.log.Error(err,
+				fmt.Sprintf(
+					"invalid env config for %s provided, using default value: %d or %d depending on resolver",
+					envVarName, defaultRpcPort, defaultInProcessPort,
+				))
+		} else {
+			cfg.Port = uint16(port)
+		}
+	}
+}
+
 // ProviderOptions
 
 type ProviderOption func(*ProviderConfiguration)

providers/flagd/pkg/configuration_test.go

@@ -1,7 +1,10 @@
 package flagd
 
 import (
+	"os"
 	"testing"
+
+	"github.com/go-logr/logr"
 )
 
 func TestConfigureProviderConfigurationInProcessWithOfflineFile(t *testing.T) {
@@ -64,3 +67,100 @@
 		t.Errorf("Error expected but check succeeded")
 	}
 }
+
+func TestUpdatePortFromEnvVarInProcessWithSyncPort(t *testing.T) {
+	// given
+	os.Setenv("FLAGD_SYNC_PORT", "9999")
+	defer os.Unsetenv("FLAGD_SYNC_PORT")
+
+	providerConfiguration := &ProviderConfiguration{
+		Resolver: inProcess,
+		log:      logr.Discard(),
+	}
+
+	// when
+	providerConfiguration.updatePortFromEnvVar()
+
+	// then
+	if providerConfiguration.Port != 9999 {
+		t.Errorf("incorrect Port, expected %v, got %v", 9999, providerConfiguration.Port)
+	}
+}
+
+func TestUpdatePortFromEnvVarInProcessWithLegacyPort(t *testing.T) {
+	// given - for backwards compatibility, FLAGD_PORT should work for in-process
+	os.Setenv("FLAGD_PORT", "8888")
+	defer os.Unsetenv("FLAGD_PORT")
+
+	providerConfiguration := &ProviderConfiguration{
+		Resolver: inProcess,
+		log:      logr.Discard(),
+	}
+
+	// when
+	providerConfiguration.updatePortFromEnvVar()
+
+	// then
+	if providerConfiguration.Port != 8888 {
+		t.Errorf("incorrect Port, expected %v, got %v", 8888, providerConfiguration.Port)
+	}
+}
+
+func TestUpdatePortFromEnvVarInProcessSyncPortPriority(t *testing.T) {
+	// given - FLAGD_SYNC_PORT takes priority over FLAGD_PORT
+	os.Setenv("FLAGD_SYNC_PORT", "9999")
+	os.Setenv("FLAGD_PORT", "8888")
+	defer os.Unsetenv("FLAGD_SYNC_PORT")
+	defer os.Unsetenv("FLAGD_PORT")
+
+	providerConfiguration := &ProviderConfiguration{
+		Resolver: inProcess,
+		log:      logr.Discard(),
+	}
+
+	// when
+	providerConfiguration.updatePortFromEnvVar()
+
+	// then
+	if providerConfiguration.Port != 9999 {
+		t.Errorf("incorrect Port, expected %v, got %v", 9999, providerConfiguration.Port)
+	}
+}
+
+func TestUpdatePortFromEnvVarRpcWithPort(t *testing.T) {
+	// given - RPC resolver uses FLAGD_PORT
+	os.Setenv("FLAGD_PORT", "8888")
+	defer os.Unsetenv("FLAGD_PORT")
+
+	providerConfiguration := &ProviderConfiguration{
+		Resolver: rpc,
+		log:      logr.Discard(),
+	}
+
+	// when
+	providerConfiguration.updatePortFromEnvVar()
+
+	// then
+	if providerConfiguration.Port != 8888 {
+		t.Errorf("incorrect Port, expected %v, got %v", 8888, providerConfiguration.Port)
+	}
+}
+
+func TestUpdatePortFromEnvVarRpcIgnoresSyncPort(t *testing.T) {
+	// given - RPC resolver should NOT use FLAGD_SYNC_PORT
+	os.Setenv("FLAGD_SYNC_PORT", "9999")
+	defer os.Unsetenv("FLAGD_SYNC_PORT")
+
+	providerConfiguration := &ProviderConfiguration{
+		Resolver: rpc,
+		log:      logr.Discard(),
+	}
+
+	// when
+	providerConfiguration.updatePortFromEnvVar()
+
+	// then - port should remain 0 (unset) since FLAGD_PORT is not set
+	if providerConfiguration.Port != 0 {
+		t.Errorf("incorrect Port, expected %v, got %v", 0, providerConfiguration.Port)
+	}
+}

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

@@ -138,7 +138,7 @@ func TestInProcessProviderEvaluationEnvoy(t *testing.T) {
 	}
 
 	inProcessService := NewInProcessService(Configuration{
-		TargetUri: "envoy://localhost:9211/foo.service",
+		TargetUri:  "envoy://localhost:9211/foo.service",
 		Selector:   scope,
 		TLSEnabled: false,
 	})
@@ -201,7 +201,6 @@ func TestInProcessProviderEvaluationEnvoy(t *testing.T) {
 	}
 }
 
-
 // bufferedServer - a mock grpc service backed by buffered connection
 type bufferedServer struct {
 	listener              net.Listener

providers/flagd/pkg/service/rpc/service.go

@@ -452,7 +452,7 @@ func (s *Service) EventChannel() <-chan of.Event {
 // If retrying is exhausted, an event with openfeature.ProviderError will be emitted.
 func (s *Service) startEventStream(ctx context.Context) {
 	streamReadySignaled := false
-	
+
 	// wraps connection with retry attempts
 	for s.retryCounter.retry() {
 		s.logger.V(logger.Debug).Info("connecting to event stream")
@@ -488,12 +488,12 @@ func (s *Service) startEventStream(ctx context.Context) {
 	// retry attempts exhausted. Disable cache and emit error event
 	s.cache.Disable()
 	connErr := fmt.Errorf("grpc connection establishment failed")
-	
+
 	// Signal error if we haven't signaled success yet
 	if !streamReadySignaled {
 		s.signalStreamReady(connErr)
 	}
-	
+
 	s.sendEvent(ctx, of.Event{
 		ProviderName: "flagd",
 		EventType:    of.ProviderError,
@@ -521,7 +521,7 @@ func (s *Service) streamClient(ctx context.Context, streamReadySignaled *bool) e
 	}
 
 	s.logger.V(logger.Info).Info("connected to event stream")
-	
+
 	// Signal successful connection to Init() - stream is now ready
 	if !*streamReadySignaled {
 		s.signalStreamReady(nil) // nil means success