feat: make enricher configurable

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

providers/flagd/internal/mock/service_mock.go

@@ -3,6 +3,7 @@ package flagd
 import (
 	"errors"
 	"fmt"
+	of "github.com/open-feature/go-sdk/openfeature"
 	"os"
 	"strconv"
 	"strings"
@@ -64,6 +65,7 @@ type ProviderConfiguration struct {
 	CustomSyncProvider               sync.ISync
 	CustomSyncProviderUri            string
 	GrpcDialOptionsOverride          []grpc.DialOption
+	ContextEnricher                  ContextEnricher
 
 	log logr.Logger
 }
@@ -77,6 +79,10 @@ func newDefaultConfiguration(log logr.Logger) *ProviderConfiguration {
 		MaxCacheSize:                     defaultMaxCacheSize,
 		Resolver:                         defaultResolver,
 		Tls:                              defaultTLS,
+		ContextEnricher: func(contextValues map[string]any) *of.EvaluationContext {
+			evaluationContext := of.NewTargetlessEvaluationContext(contextValues)
+			return &evaluationContext
+		},
 	}
 
 	p.updateFromEnvVar()
@@ -397,3 +403,10 @@ func WithGrpcDialOptionsOverride(grpcDialOptionsOverride []grpc.DialOption) Prov
 		p.GrpcDialOptionsOverride = grpcDialOptionsOverride
 	}
 }
+
+// WithContextEnricher allows to add a custom context enricher (BeforeHook)
+func WithContextEnricher(contextEnricher ContextEnricher) ProviderOption {
+	return func(p *ProviderConfiguration) {
+		p.ContextEnricher = contextEnricher
+	}
+}

providers/flagd/pkg/configuration.go

@@ -21,4 +21,5 @@ type IService interface {
 	ResolveObject(ctx context.Context, key string, defaultValue interface{},
 		evalCtx map[string]interface{}) of.InterfaceResolutionDetail
 	EventChannel() <-chan of.Event
+	ContextValues() map[string]any
 }

providers/flagd/pkg/iservice.go

@@ -61,7 +61,7 @@ func NewProvider(opts ...ProviderOption) (*Provider, error) {
 			provider.providerConfiguration.log,
 			provider.providerConfiguration.EventStreamConnectionMaxAttempts)
 	} else if provider.providerConfiguration.Resolver == inProcess {
-		inprocess_service := process.NewInProcessService(process.Configuration{
+		service = process.NewInProcessService(process.Configuration{
 			Host:                    provider.providerConfiguration.Host,
 			Port:                    provider.providerConfiguration.Port,
 			ProviderID:              provider.providerConfiguration.ProviderID,
@@ -73,19 +73,16 @@ func NewProvider(opts ...ProviderOption) (*Provider, error) {
 			CustomSyncProviderUri:   provider.providerConfiguration.CustomSyncProviderUri,
 			GrpcDialOptionsOverride: provider.providerConfiguration.GrpcDialOptionsOverride,
 		})
-		provider.hooks = append(provider.hooks, NewSyncContextHook(
-			func() *of.EvaluationContext {
-				evaluationContext := of.NewTargetlessEvaluationContext(inprocess_service.ContextValues)
-				return &evaluationContext
-			}))
-		service = inprocess_service
 
 	} else {
 		service = process.NewInProcessService(process.Configuration{
 			OfflineFlagSource: provider.providerConfiguration.OfflineFlagSourcePath,
 		})
 	}
 
+	provider.hooks = append(provider.hooks, NewSyncContextHook(func() *of.EvaluationContext {
+		return provider.providerConfiguration.ContextEnricher(service.ContextValues())
+	}))
 	provider.service = service
 
 	return provider, nil

providers/flagd/pkg/provider.go

@@ -22,6 +22,12 @@ func TestNewProvider(t *testing.T) {
 		grpc.WithAuthority("test-authority"),
 	}
 
+	enrichment := make(map[string]any)
+	enrichment["test"] = "test"
+
+	expectedEnrichment := make(map[string]any)
+	expectedEnrichment["test"] = "test"
+	expectedEnrichment["test2"] = "test2"
 	tests := []struct {
 		name                          string
 		expectedResolver              ResolverType
@@ -41,6 +47,7 @@ func TestNewProvider(t *testing.T) {
 		expectCustomSyncProviderUri   string
 		expectOfflineFlagSourcePath   string
 		expectGrpcDialOptionsOverride []grpc.DialOption
+		expectContextEnrichment       map[string]any
 		options                       []ProviderOption
 	}{
 		{
@@ -269,6 +276,41 @@ func TestNewProvider(t *testing.T) {
 				WithOfflineFilePath("offlineFilePath"),
 			},
 		},
+		{
+			name:                    "with ContextEnricher inprocess resolver",
+			expectedResolver:        inProcess,
+			expectHost:              defaultHost,
+			expectPort:              defaultInProcessPort,
+			expectCacheType:         defaultCache,
+			expectCacheSize:         defaultMaxCacheSize,
+			expectMaxRetries:        defaultMaxEventStreamRetries,
+			expectContextEnrichment: enrichment,
+			options: []ProviderOption{
+				WithInProcessResolver(),
+				WithContextEnricher(func(m map[string]any) *of.EvaluationContext {
+					context := of.NewTargetlessEvaluationContext(m)
+					return &context
+				}),
+			},
+		},
+		{
+			name:                    "with ContextEnricher inprocess resolver adding values",
+			expectedResolver:        inProcess,
+			expectHost:              defaultHost,
+			expectPort:              defaultInProcessPort,
+			expectCacheType:         defaultCache,
+			expectCacheSize:         defaultMaxCacheSize,
+			expectMaxRetries:        defaultMaxEventStreamRetries,
+			expectContextEnrichment: expectedEnrichment,
+			options: []ProviderOption{
+				WithInProcessResolver(),
+				WithContextEnricher(func(m map[string]any) *of.EvaluationContext {
+					m["test2"] = "test2"
+					context := of.NewTargetlessEvaluationContext(m)
+					return &context
+				}),
+			},
+		},
 	}
 
 	for _, test := range tests {
@@ -369,6 +411,15 @@ func TestNewProvider(t *testing.T) {
 				}
 			}
 
+			if test.expectContextEnrichment != nil {
+				enriched := config.ContextEnricher(enrichment).Attributes()
+				for k, v := range test.expectContextEnrichment {
+					if enriched[k] != v {
+						t.Errorf("incorrect context_enrichment attribute, expected %v, got %v", v, enriched[k])
+					}
+				}
+			}
+
 			// this line will fail linting if this provider is no longer compatible with the openfeature sdk
 			var _ of.FeatureProvider = flagdProvider
 		})

providers/flagd/pkg/provider_test.go

@@ -32,7 +32,7 @@ type InProcess struct {
 	sync             sync.ISync
 	syncEnd          context.CancelFunc
 	wg               parallel.WaitGroup
-	ContextValues    map[string]any
+	contextValues    map[string]any
 }
 
 type Configuration struct {
@@ -113,7 +113,7 @@ func (i *InProcess) Init() error {
 				// re-syncs are ignored as we only support single flag sync source
 				changes, _, err := i.evaluator.SetState(data)
 				if data.SyncContext != nil {
-					i.ContextValues = data.SyncContext.AsMap()
+					i.contextValues = data.SyncContext.AsMap()
 				}
 
 				if err != nil {
@@ -297,6 +297,10 @@ func (i *InProcess) appendMetadata(evalMetadata model.Metadata) {
 	}
 }
 
+func (i *InProcess) ContextValues() map[string]any {
+	return i.contextValues
+}
+
 // makeSyncProvider is a helper to create sync.ISync and return the underlying uri used by it to the caller
 func makeSyncProvider(cfg Configuration, log *logger.Logger) (sync.ISync, string) {
 	if cfg.CustomSyncProvider != nil {

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

@@ -123,7 +123,7 @@ func TestInProcessProviderEvaluation(t *testing.T) {
 		t.Fatalf("Wrong scope value. Expected %s, but got %s", scope, detail.FlagMetadata["scope"])
 	}
 
-	if len(inProcessService.ContextValues) == 0 {
+	if len(inProcessService.contextValues) == 0 {
 		t.Fatal("Expected context_values to be present, but got none")
 	}
 }

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

@@ -435,6 +435,10 @@ func handleError(err error) openfeature.ResolutionError {
 	return openfeature.NewGeneralResolutionError(err.Error())
 }
 
+func (s *Service) ContextValues() map[string]any {
+	return nil
+}
+
 func (s *Service) EventChannel() <-chan of.Event {
 	return s.events
 }

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

@@ -5,17 +5,17 @@ import (
 	"github.com/open-feature/go-sdk/openfeature"
 )
 
-type Supplier func() *openfeature.EvaluationContext
+type ContextEnricher func(map[string]any) *openfeature.EvaluationContext
 
 type SyncContextHook struct {
 	openfeature.UnimplementedHook
-	contextSupplier Supplier
+	contextEnricher func() *openfeature.EvaluationContext
 }
 
-func NewSyncContextHook(contextSupplier Supplier) SyncContextHook {
-	return SyncContextHook{contextSupplier: contextSupplier}
+func NewSyncContextHook(contextEnricher func() *openfeature.EvaluationContext) SyncContextHook {
+	return SyncContextHook{contextEnricher: contextEnricher}
 }
 
 func (hook SyncContextHook) Before(ctx context.Context, hookContext openfeature.HookContext, hookHints openfeature.HookHints) (*openfeature.EvaluationContext, error) {
-	return hook.contextSupplier(), nil
+	return hook.contextEnricher(), nil
 }