apply @genesor suggestions

Signed-off-by: Eliott Bouhana <[email protected]>

Author: eliottness

openfeature/doc.go

@@ -226,7 +226,7 @@
 //	    defer tracer.Stop()
 //
 //	    // Create OpenFeature provider
-//	    provider, err := openfeature.NewDatadogProvider()
+//	    provider, err := openfeature.NewDatadogProvider(openfeature.ProviderConfig{})
 //	    if err != nil {
 //	        log.Fatalf("Failed to create provider: %v", err)
 //	    }
@@ -278,7 +278,7 @@
 //	provider := openfeature.newDatadogProvider()
 //
 //	// Manually set test configuration
-//	config := &serverConfiguration{
+//	config := &universalFlagConfiguration{
 //	    Format: "SERVER",
 //	    Flags: map[string]*flag{
 //	        "test-flag": {

openfeature/integration_test.go

@@ -814,20 +814,20 @@ func TestEndToEnd_JSONSerialization(t *testing.T) {
 	originalConfig := createE2EBooleanConfig()
 
 	// Serialize to JSON
-	data, err := json.Marshal(serverConfiguration{originalConfig})
+	data, err := json.Marshal(originalConfig)
 	if err != nil {
 		t.Fatalf("failed to marshal config: %v", err)
 	}
 
 	// Deserialize from JSON
-	var parsedConfig serverConfiguration
+	var parsedConfig universalFlagsConfiguration
 	if err := json.Unmarshal(data, &parsedConfig); err != nil {
 		t.Fatalf("failed to unmarshal config: %v", err)
 	}
 
 	// Use the parsed config
 	provider := newDatadogProvider()
-	provider.updateConfiguration(&parsedConfig.FlagConfiguration)
+	provider.updateConfiguration(&parsedConfig)
 
 	err = of.SetProviderAndWait(provider)
 	if err != nil {

openfeature/provider.go

@@ -38,6 +38,10 @@ type DatadogProvider struct {
 	configChange sync.Cond
 }
 
+type ProviderConfig struct {
+	// Add any configuration fields if needed in the future
+}
+
 // NewDatadogProvider creates a new Datadog OpenFeature provider.
 // It subscribes to Remote Config updates and automatically updates the provider's configuration
 // when new flag configurations are received.
@@ -47,9 +51,10 @@ type DatadogProvider struct {
 //
 // Returns an error if the default configuration of the Remote Config client is NOT working
 // In this case, please call tracer.Start before creating the provider.
-func NewDatadogProvider() (*DatadogProvider, error) {
+func NewDatadogProvider(ProviderConfig) (openfeature.FeatureProvider, error) {
 	if !internal.BoolEnv(ffeProductEnvVar, false) {
-		return nil, fmt.Errorf("experimental flagging provider is not enabled: set %s=true to enable it", ffeProductEnvVar)
+		log.Error("openfeature: experimental flagging provider is not enabled, please set %s=true to enable it", ffeProductEnvVar)
+		return &openfeature.NoopProvider{}, nil
 	}
 
 	return startWithRemoteConfig()

openfeature/remoteconfig.go

@@ -72,7 +72,7 @@ func processConfigUpdate(provider *DatadogProvider, path string, data []byte) rc
 	// Parse the configuration
 	log.Debug("openfeature: remote config: processing configuration update %q: %s", path, string(data))
 
-	var config serverConfiguration
+	var config universalFlagsConfiguration
 	if err := json.Unmarshal(data, &config); err != nil {
 		log.Error("openfeature: remote config: failed to unmarshal configuration %q: %v", path, err.Error())
 		return rc.ApplyStatus{
@@ -82,7 +82,7 @@ func processConfigUpdate(provider *DatadogProvider, path string, data []byte) rc
 	}
 
 	// Validate the configuration
-	err := validateConfiguration(&config.FlagConfiguration)
+	err := validateConfiguration(&config)
 	if err != nil {
 		log.Error("openfeature: remote config: invalid configuration %q: %v", path, err.Error())
 		return rc.ApplyStatus{
@@ -92,8 +92,8 @@ func processConfigUpdate(provider *DatadogProvider, path string, data []byte) rc
 	}
 
 	// Update the provider with the new configuration
-	provider.updateConfiguration(&config.FlagConfiguration)
-	log.Debug("openfeature: remote config: successfully applied configuration %q with %d flags", path, len(config.FlagConfiguration.Flags))
+	provider.updateConfiguration(&config)
+	log.Debug("openfeature: remote config: successfully applied configuration %q with %d flags", path, len(config.Flags))
 
 	return rc.ApplyStatus{
 		State: rc.ApplyStateAcknowledged,
@@ -102,13 +102,11 @@ func processConfigUpdate(provider *DatadogProvider, path string, data []byte) rc
 
 // validateConfiguration performs basic validation on a serverConfiguration.
 func validateConfiguration(config *universalFlagsConfiguration) error {
-	if config == nil {
-		return fmt.Errorf("configuration is nil")
+	if config.Format != "SERVER" {
+		return fmt.Errorf("unsupported format %q, expected SERVER (Is the remote config payload the right format ?)", config.Format)
 	}
 
-	if config.Format != "SERVER" && config.Format != "" {
-		return fmt.Errorf("unsupported format %q, expected SERVER", config.Format)
-	}
+	hasFlags := len(config.Flags) > 0
 
 	// Validate each flag and delete invalid ones from the map
 	// Collect errors for reporting
@@ -119,6 +117,10 @@ func validateConfiguration(config *universalFlagsConfiguration) error {
 		return err != nil
 	})
 
+	if hasFlags && len(config.Flags) == 0 {
+		errs = append(errs, errors.New("all flags are invalid"))
+	}
+
 	return errors.Join(errs...)
 }
 

openfeature/remoteconfig_test.go

@@ -434,7 +434,7 @@ func TestProcessConfigUpdate(t *testing.T) {
 			},
 		}
 
-		data, err := json.Marshal(serverConfiguration{config})
+		data, err := json.Marshal(config)
 		if err != nil {
 			t.Fatalf("failed to marshal config: %v", err)
 		}
@@ -508,7 +508,7 @@ func TestProcessConfigUpdate(t *testing.T) {
 			Flags:  map[string]*flag{},
 		}
 
-		data, _ := json.Marshal(serverConfiguration{config})
+		data, _ := json.Marshal(config)
 		status := processConfigUpdate(provider, "test-path", data)
 
 		if status.State != rc.ApplyStateError {
@@ -553,7 +553,7 @@ func TestCreateRemoteConfigCallback(t *testing.T) {
 		},
 	}
 
-	data, _ := json.Marshal(serverConfiguration{config})
+	data, _ := json.Marshal(config)
 
 	// Simulate Remote Config update with multiple paths
 	update := remoteconfig.ProductUpdate{
@@ -613,8 +613,8 @@ func TestRemoteConfigIntegration(t *testing.T) {
 			},
 		}
 
-		data1, _ := json.Marshal(serverConfiguration{config1})
-		data2, _ := json.Marshal(serverConfiguration{config2})
+		data1, _ := json.Marshal(config1)
+		data2, _ := json.Marshal(config2)
 
 		// First update
 		update1 := remoteconfig.ProductUpdate{
@@ -663,7 +663,7 @@ func TestRemoteConfigIntegration(t *testing.T) {
 			},
 		}
 
-		validData, _ := json.Marshal(serverConfiguration{validConfig})
+		validData, _ := json.Marshal(validConfig)
 		invalidData := []byte("{invalid")
 
 		update := remoteconfig.ProductUpdate{
@@ -721,7 +721,7 @@ func TestConfigurationPersistence(t *testing.T) {
 
 	// Apply configurations sequentially
 	for i, config := range configs {
-		data, _ := json.Marshal(serverConfiguration{config})
+		data, _ := json.Marshal(config)
 		update := remoteconfig.ProductUpdate{
 			"config": data,
 		}

openfeature/types.go

@@ -7,12 +7,6 @@ package openfeature
 
 import "time"
 
-// serverConfiguration represents the top-level configuration received from Remote Config.
-// It contains the feature flags configuration for a specific environment.
-type serverConfiguration struct {
-	FlagConfiguration universalFlagsConfiguration `json:"flag_configuration"`
-}
-
 // universalFlagsConfiguration represents the universal feature flags configuration structure.
 // of the openfeature standard for server-side flag configurations.
 type universalFlagsConfiguration struct {