Feature: Add multi-selector support to flagd

Signed-off-by: Nilushiya.K <Nilushiya.K@cloudsolutions.com.sa>

Author: Nilushiya.K

flagd/pkg/service/constants.go

@@ -1,3 +1,5 @@
 package service
 
 const FLAGD_SELECTOR_HEADER = "Flagd-Selector"
+
+const FLAG_SELECTOR_HEADER = "flag-selector"

flagd/pkg/service/flag-evaluation/flag_evaluator.go

@@ -75,11 +75,15 @@ func (s *OldFlagEvaluationService) ResolveAll(
 		Flags: make(map[string]*schemaV1.AnyFlag),
 	}
 
-	selectorExpression := req.Header().Get(flagdService.FLAGD_SELECTOR_HEADER)
-	selector := store.NewSelector(selectorExpression)
-	ctx = context.WithValue(ctx, store.SelectorContextKey{}, selector)
+	selectorExpression := flagdService.SelectorExpressionFromHTTPHeaders(req.Header())
 
-	values, _, err := s.eval.ResolveAllValues(ctx, reqID, mergeContexts(req.Msg.GetContext().AsMap(), s.contextValues, req.Header(), make(map[string]string)))
+	values, _, err := ResolveAllWithSelectorMerge(
+		ctx,
+		reqID,
+		s.eval,
+		mergeContexts(req.Msg.GetContext().AsMap(), s.contextValues, req.Header(), make(map[string]string)),
+		selectorExpression,
+	)
 	if err != nil {
 		s.logger.WarnWithID(reqID, fmt.Sprintf("error resolving all flags: %v", err))
 		return nil, fmt.Errorf("error resolving flags. Tracking ID: %s", reqID)

flagd/pkg/service/flag-evaluation/flag_evaluator_v1.go

@@ -75,13 +75,11 @@ func (s *FlagEvaluationService) ResolveAll(
 		Flags: make(map[string]*evalV1.AnyFlag),
 	}
 
-	selectorExpression := req.Header().Get(flagdService.FLAGD_SELECTOR_HEADER)
-	selector := store.NewSelector(selectorExpression)
+	selectorExpression := flagdService.SelectorExpressionFromHTTPHeaders(req.Header())
 	evaluationContext := mergeContexts(req.Msg.GetContext().AsMap(), s.contextValues, req.Header(), s.headerToContextKeyMappings)
-	ctx = context.WithValue(ctx, store.SelectorContextKey{}, selector)
 	ctx = context.WithValue(ctx, evaluator.ProtoVersionKey, "v1")
 
-	resolutions, flagSetMetadata, err := s.eval.ResolveAllValues(ctx, reqID, evaluationContext)
+	resolutions, flagSetMetadata, err := ResolveAllWithSelectorMerge(ctx, reqID, s.eval, evaluationContext, selectorExpression)
 	if err != nil {
 		s.logger.WarnWithID(reqID, fmt.Sprintf("error resolving all flags: %v", err))
 		return nil, fmt.Errorf("error resolving flags. Tracking ID: %s", reqID)

flagd/pkg/service/flag-evaluation/ofrep/handler.go

@@ -94,7 +94,7 @@ func (h *handler) HandleFlagEvaluation(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	evaluationContext := flagdContext(h.Logger, requestID, request, h.contextValues, r.Header, h.headerToContextKeyMappings)
-	selectorExpression := r.Header.Get(service.FLAGD_SELECTOR_HEADER)
+	selectorExpression := service.SelectorExpressionFromHTTPHeaders(r.Header)
 	selector := store.NewSelector(selectorExpression)
 	ctx := context.WithValue(r.Context(), store.SelectorContextKey{}, selector)
 
@@ -118,11 +118,10 @@ func (h *handler) HandleBulkEvaluation(w http.ResponseWriter, r *http.Request) {
 	}
 
 	evaluationContext := flagdContext(h.Logger, requestID, request, h.contextValues, r.Header, h.headerToContextKeyMappings)
-	selectorExpression := r.Header.Get(service.FLAGD_SELECTOR_HEADER)
-	selector := store.NewSelector(selectorExpression)
-	ctx := context.WithValue(r.Context(), store.SelectorContextKey{}, selector)
+	selectorExpression := service.SelectorExpressionFromHTTPHeaders(r.Header)
+	ctx := r.Context()
 
-	evaluations, metadata, err := h.evaluator.ResolveAllValues(ctx, requestID, evaluationContext)
+	evaluations, metadata, err := evalservice.ResolveAllWithSelectorMerge(ctx, requestID, h.evaluator, evaluationContext, selectorExpression)
 	if err != nil {
 		h.Logger.WarnWithID(requestID, fmt.Sprintf("error from resolver: %v", err))
 

flagd/pkg/service/flag-evaluation/ofrep/handler_test.go

@@ -2,6 +2,7 @@ package ofrep
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"io"
@@ -16,6 +17,9 @@ import (
 	"github.com/open-feature/flagd/core/pkg/logger"
 	"github.com/open-feature/flagd/core/pkg/model"
 	"github.com/open-feature/flagd/core/pkg/service/ofrep"
+	"github.com/open-feature/flagd/core/pkg/store"
+	service "github.com/open-feature/flagd/flagd/pkg/service"
+	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 )
 
@@ -270,6 +274,44 @@ func Test_handler_HandleBulkEvaluation(t *testing.T) {
 	}
 }
 
+func Test_handler_HandleBulkEvaluation_UsesFlagSelectorHeader(t *testing.T) {
+	log := logger.NewLogger(nil, false)
+	eval := mock.NewMockIEvaluator(gomock.NewController(t))
+	expectedOrder := []string{"'source=A'", "'source=C'", "'source=B'"}
+	callCount := 0
+
+	eval.EXPECT().ResolveAllValues(gomock.Any(), gomock.Any(), gomock.Any()).Times(3).DoAndReturn(
+		func(ctx context.Context, _ string, _ map[string]any) ([]evaluator.AnyValue, model.Metadata, error) {
+			selector, ok := ctx.Value(store.SelectorContextKey{}).(store.Selector)
+			if !ok {
+				t.Fatalf("selector not found in context")
+			}
+
+			if callCount >= len(expectedOrder) {
+				t.Fatalf("unexpected extra selector call")
+			}
+			if selector.ToLogString() != expectedOrder[callCount] {
+				t.Fatalf("unexpected selector at call %d: %s", callCount, selector.ToLogString())
+			}
+			callCount++
+
+			return []evaluator.AnyValue{successValue}, model.Metadata{}, nil
+		},
+	)
+
+	h := handler{Logger: log, evaluator: eval}
+	request, err := http.NewRequest(http.MethodPost, "/ofrep/v1/evaluate/flags", bytes.NewReader([]byte("{}")))
+	require.NoError(t, err)
+	request.Header.Set(service.FLAG_SELECTOR_HEADER, "A,C,B")
+
+	recorder := httptest.NewRecorder()
+	router := mux.NewRouter()
+	router.HandleFunc(bulkEvaluation, h.HandleBulkEvaluation)
+	router.ServeHTTP(recorder, request)
+
+	require.Equal(t, http.StatusOK, recorder.Code)
+}
+
 func TestWriteJSONResponse(t *testing.T) {
 	log := logger.NewLogger(nil, false)
 	h := handler{Logger: log}

flagd/pkg/service/flag-evaluation/selector_merge.go

@@ -0,0 +1,79 @@
+package service
+
+import (
+	"context"
+	"sort"
+	"strings"
+
+	"github.com/open-feature/flagd/core/pkg/evaluator"
+	"github.com/open-feature/flagd/core/pkg/model"
+	"github.com/open-feature/flagd/core/pkg/store"
+)
+
+func ResolveAllWithSelectorMerge(
+	ctx context.Context,
+	reqID string,
+	eval evaluator.IEvaluator,
+	evaluationContext map[string]any,
+	selectorExpression string,
+) ([]evaluator.AnyValue, model.Metadata, error) {
+	selectors := splitSelectorExpression(selectorExpression)
+
+	switch len(selectors) {
+	case 0:
+		return eval.ResolveAllValues(ctx, reqID, evaluationContext)
+	case 1:
+		selector := store.NewSelector(selectors[0])
+		selectorCtx := context.WithValue(ctx, store.SelectorContextKey{}, selector)
+		return eval.ResolveAllValues(selectorCtx, reqID, evaluationContext)
+	default:
+		mergedValues := map[string]evaluator.AnyValue{}
+		mergedMetadata := model.Metadata{}
+
+		for _, selectorExpression := range selectors {
+			selector := store.NewSelector(selectorExpression)
+			selectorCtx := context.WithValue(ctx, store.SelectorContextKey{}, selector)
+			values, metadata, err := eval.ResolveAllValues(selectorCtx, reqID, evaluationContext)
+			if err != nil {
+				return nil, nil, err
+			}
+
+			for key, value := range metadata {
+				mergedMetadata[key] = value
+			}
+			for _, value := range values {
+				mergedValues[value.FlagKey] = value
+			}
+		}
+
+		keys := make([]string, 0, len(mergedValues))
+		for key := range mergedValues {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+
+		resolutions := make([]evaluator.AnyValue, 0, len(keys))
+		for _, key := range keys {
+			resolutions = append(resolutions, mergedValues[key])
+		}
+
+		return resolutions, mergedMetadata, nil
+	}
+}
+
+func splitSelectorExpression(selectorExpression string) []string {
+	if strings.TrimSpace(selectorExpression) == "" {
+		return nil
+	}
+
+	parts := strings.Split(selectorExpression, ",")
+	selectors := make([]string, 0, len(parts))
+	for _, part := range parts {
+		trimmed := strings.TrimSpace(part)
+		if trimmed == "" {
+			continue
+		}
+		selectors = append(selectors, trimmed)
+	}
+	return selectors
+}

flagd/pkg/service/flag-sync/handler.go

@@ -6,6 +6,8 @@ import (
 	"errors"
 	"fmt"
 	"maps"
+	"sort"
+	"strings"
 	"time"
 
 	"github.com/open-feature/flagd/core/pkg/model"
@@ -35,7 +37,7 @@ type syncHandler struct {
 func (s syncHandler) SyncFlags(req *syncv1.SyncFlagsRequest, server syncv1grpc.FlagSyncService_SyncFlagsServer) error {
 	watcher := make(chan store.FlagQueryResult, 1)
 	selectorExpression := s.getSelectorExpression(server.Context(), req)
-	selector := store.NewSelector(selectorExpression)
+	selectors := parseSelectorList(selectorExpression)
 	ctx := server.Context()
 
 	syncContextMap := make(map[string]any)
@@ -53,7 +55,15 @@ func (s syncHandler) SyncFlags(req *syncv1.SyncFlagsRequest, server syncv1grpc.F
 		defer cancel()
 	}
 
-	s.store.Watch(ctx, &selector, watcher)
+	switch len(selectors) {
+	case 0:
+		s.store.Watch(ctx, nil, watcher)
+	case 1:
+		s.store.Watch(ctx, &selectors[0], watcher)
+	default:
+		// For multi-selector requests, watch all updates and recompute merged view in order.
+		s.store.Watch(ctx, nil, watcher)
+	}
 
 	for {
 		select {
@@ -63,7 +73,16 @@ func (s syncHandler) SyncFlags(req *syncv1.SyncFlagsRequest, server syncv1grpc.F
 				return fmt.Errorf("error constructing metadata response")
 			}
 
-			flags, err := s.generateResponse(payload.Flags)
+			flagsToSend := payload.Flags
+			if len(selectors) != 1 {
+				flagsToSend, err = s.fetchMergedFlags(ctx, selectors)
+				if err != nil {
+					s.log.Error(fmt.Sprintf("error retrieving merged flags from store: %v", err))
+					return status.Error(codes.Internal, "error retrieving flags from store")
+				}
+			}
+
+			flags, err := s.generateResponse(flagsToSend)
 			if err != nil {
 				s.log.Error(fmt.Sprintf("error retrieving flags from store: %v", err))
 				return status.Error(codes.DataLoss, "error marshalling flags")
@@ -103,8 +122,7 @@ func (s syncHandler) generateResponse(payload []model.Flag) ([]byte, error) {
 func (s syncHandler) getSelectorExpression(ctx context.Context, req interface{}) string {
 	// Try to get selector from metadata (header)
 	if md, ok := metadata.FromIncomingContext(ctx); ok {
-		if values := md.Get(flagdService.FLAGD_SELECTOR_HEADER); len(values) > 0 {
-			headerSelector := values[0]
+		if headerSelector := flagdService.SelectorExpressionFromGRPCMetadata(md); headerSelector != "" {
 			s.log.Debug(fmt.Sprintf("using selector from request header: %s", headerSelector))
 			return headerSelector
 		}
@@ -139,8 +157,7 @@ func (s syncHandler) FetchAllFlags(ctx context.Context, req *syncv1.FetchAllFlag
 	*syncv1.FetchAllFlagsResponse, error,
 ) {
 	selectorExpression := s.getSelectorExpression(ctx, req)
-	selector := store.NewSelector(selectorExpression)
-	flags, _, err := s.store.GetAll(ctx, &selector)
+	flags, err := s.fetchMergedFlags(ctx, parseSelectorList(selectorExpression))
 	if err != nil {
 		s.log.Error(fmt.Sprintf("error retrieving flags from store: %v", err))
 		return nil, status.Error(codes.Internal, "error retrieving flags from store")
@@ -157,8 +174,66 @@ func (s syncHandler) FetchAllFlags(ctx context.Context, req *syncv1.FetchAllFlag
 	}, nil
 }
 
+func parseSelectorList(selectorExpression string) []store.Selector {
+	if strings.TrimSpace(selectorExpression) == "" {
+		return nil
+	}
+
+	parts := strings.Split(selectorExpression, ",")
+	selectors := make([]store.Selector, 0, len(parts))
+	for _, part := range parts {
+		trimmed := strings.TrimSpace(part)
+		if trimmed == "" {
+			continue
+		}
+		selector := store.NewSelector(trimmed)
+		selectors = append(selectors, selector)
+	}
+	return selectors
+}
+
+func (s syncHandler) fetchMergedFlags(ctx context.Context, selectors []store.Selector) ([]model.Flag, error) {
+	switch len(selectors) {
+	case 0:
+		flags, _, err := s.store.GetAll(ctx, nil)
+		return flags, err
+	case 1:
+		flags, _, err := s.store.GetAll(ctx, &selectors[0])
+		return flags, err
+	default:
+		type flagIdentifier struct {
+			flagSetID string
+			key       string
+		}
+
+		merged := map[flagIdentifier]model.Flag{}
+		for _, selector := range selectors {
+			flags, _, err := s.store.GetAll(ctx, &selector)
+			if err != nil {
+				return nil, err
+			}
+			for _, flag := range flags {
+				merged[flagIdentifier{flagSetID: flag.FlagSetId, key: flag.Key}] = flag
+			}
+		}
+
+		out := make([]model.Flag, 0, len(merged))
+		for _, flag := range merged {
+			out = append(out, flag)
+		}
+		sort.Slice(out, func(i, j int) bool {
+			if out[i].FlagSetId != out[j].FlagSetId {
+				return out[i].FlagSetId < out[j].FlagSetId
+			}
+			return out[i].Key < out[j].Key
+		})
+		return out, nil
+	}
+}
+
 // Deprecated - GetMetadata is deprecated and will be removed in a future release.
 // Use the sync_context field in syncv1.SyncFlagsResponse, providing same info.
+//
 //nolint:staticcheck // SA1019 temporarily suppress deprecation warning
 func (s syncHandler) GetMetadata(_ context.Context, _ *syncv1.GetMetadataRequest) (
 	*syncv1.GetMetadataResponse, error,