feat: Add toggle for disabling getMetadata request (#1693)

<!-- Please use this template for your pull request. -->
<!-- Please use the sections that you need and delete other sections -->

## This PR
<!-- add the description of the PR here -->

- adds a toggle `disable-sync-metadata` for the Sync Service to disable
or enable the deprecated `getMetadata` request

### Related Issues
[#1688 [FEATURE] Temporary Context Enrichment
toggle](#1688)

---------

Signed-off-by: Konvalinka <[email protected]>

Author: leakonvalinka

docs/reference/flagd-cli/flagd_start.md

@@ -14,6 +14,7 @@ flagd start [flags]
   -H, --context-from-header stringToString   add key-value pairs to map header values to context values, where key is Header name, value is context key (default [])
   -X, --context-value stringToString         add arbitrary key value pairs to the flag evaluation context (default [])
   -C, --cors-origin strings                  CORS allowed origins, * will allow all origins
+      --disable-sync-metadata                Disables the getMetadata endpoint of the sync service. Defaults to false, but will default to true in later versions.
   -h, --help                                 help for start
   -z, --log-format string                    Set the logging format, e.g. console or json (default "console")
   -m, --management-port int32                Port for management operations (default 8014)

flagd/cmd/start.go

@@ -36,6 +36,7 @@ const (
 	syncPortFlagName           = "sync-port"
 	syncSocketPathFlagName     = "sync-socket-path"
 	uriFlagName                = "uri"
+	disableSyncMetadata        = "disable-sync-metadata"
 	contextValueFlagName       = "context-value"
 	headerToContextKeyFlagName = "context-from-header"
 	streamDeadlineFlagName     = "stream-deadline"
@@ -89,6 +90,7 @@ func init() {
 	flags.StringToStringP(headerToContextKeyFlagName, "H", map[string]string{}, "add key-value pairs to map "+
 		"header values to context values, where key is Header name, value is context key")
 	flags.Duration(streamDeadlineFlagName, 0, "Set a server-side deadline for flagd sync and event streams (default 0, means no deadline).")
+	flags.Bool(disableSyncMetadata, false, "Disables the getMetadata endpoint of the sync service. Defaults to false, but will default to true in later versions.")
 
 	bindFlags(flags)
 }
@@ -114,6 +116,7 @@ func bindFlags(flags *pflag.FlagSet) {
 	_ = viper.BindPFlag(contextValueFlagName, flags.Lookup(contextValueFlagName))
 	_ = viper.BindPFlag(headerToContextKeyFlagName, flags.Lookup(headerToContextKeyFlagName))
 	_ = viper.BindPFlag(streamDeadlineFlagName, flags.Lookup(streamDeadlineFlagName))
+	_ = viper.BindPFlag(disableSyncMetadata, flags.Lookup(disableSyncMetadata))
 }
 
 // startCmd represents the start command
@@ -186,6 +189,7 @@ var startCmd = &cobra.Command{
 			SyncServicePort:            viper.GetUint16(syncPortFlagName),
 			SyncServiceSocketPath:      viper.GetString(syncSocketPathFlagName),
 			StreamDeadline:             viper.GetDuration(streamDeadlineFlagName),
+			DisableSyncMetadata:        viper.GetBool(disableSyncMetadata),
 			SyncProviders:              syncProviders,
 			ContextValues:              contextValuesToMap,
 			HeaderToContextKeyMappings: headerToContextKeyMappings,

flagd/pkg/runtime/from_config.go

@@ -39,6 +39,7 @@ type Config struct {
 	SyncServicePort       uint16
 	SyncServiceSocketPath string
 	StreamDeadline        time.Duration
+	DisableSyncMetadata   bool
 
 	SyncProviders []sync.SourceConfig
 	CORS          []string
@@ -116,15 +117,16 @@ func FromConfig(logger *logger.Logger, version string, config Config) (*Runtime,
 
 	// flag sync service
 	flagSyncService, err := flagsync.NewSyncService(flagsync.SvcConfigurations{
-		Logger:         logger.WithFields(zap.String("component", "FlagSyncService")),
-		Port:           config.SyncServicePort,
-		Sources:        sources,
-		Store:          s,
-		ContextValues:  config.ContextValues,
-		KeyPath:        config.ServiceKeyPath,
-		CertPath:       config.ServiceCertPath,
-		SocketPath:     config.SyncServiceSocketPath,
-		StreamDeadline: config.StreamDeadline,
+		Logger:              logger.WithFields(zap.String("component", "FlagSyncService")),
+		Port:                config.SyncServicePort,
+		Sources:             sources,
+		Store:               s,
+		ContextValues:       config.ContextValues,
+		KeyPath:             config.ServiceKeyPath,
+		CertPath:            config.ServiceCertPath,
+		SocketPath:          config.SyncServiceSocketPath,
+		StreamDeadline:      config.StreamDeadline,
+		DisableSyncMetadata: config.DisableSyncMetadata,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("error creating sync service: %w", err)

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

@@ -4,9 +4,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"maps"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"maps"
 	"time"
 
 	"buf.build/gen/go/open-feature/flagd/grpc/go/flagd/sync/v1/syncv1grpc"
@@ -17,10 +17,11 @@ import (
 
 // syncHandler implements the sync contract
 type syncHandler struct {
-	mux           *Multiplexer
-	log           *logger.Logger
-	contextValues map[string]any
-	deadline      time.Duration
+	mux                 *Multiplexer
+	log                 *logger.Logger
+	contextValues       map[string]any
+	deadline            time.Duration
+	disableSyncMetadata bool
 }
 
 func (s syncHandler) SyncFlags(req *syncv1.SyncFlagsRequest, server syncv1grpc.FlagSyncService_SyncFlagsServer) error {
@@ -44,7 +45,6 @@ func (s syncHandler) SyncFlags(req *syncv1.SyncFlagsRequest, server syncv1grpc.F
 	for {
 		select {
 		case payload := <-muxPayload:
-
 			metadataSrc := make(map[string]any)
 			maps.Copy(metadataSrc, s.contextValues)
 
@@ -58,10 +58,7 @@ func (s syncHandler) SyncFlags(req *syncv1.SyncFlagsRequest, server syncv1grpc.F
 				return fmt.Errorf("error constructing metadata response")
 			}
 
-			err = server.Send(&syncv1.SyncFlagsResponse{
-				FlagConfiguration: payload.flags,
-				SyncContext:       metadata,
-			})
+			err = server.Send(&syncv1.SyncFlagsResponse{FlagConfiguration: payload.flags, SyncContext: metadata})
 			if err != nil {
 				s.log.Debug(fmt.Sprintf("error sending stream response: %v", err))
 				return fmt.Errorf("error sending stream response: %w", err)
@@ -97,6 +94,9 @@ func (s syncHandler) FetchAllFlags(_ context.Context, req *syncv1.FetchAllFlagsR
 func (s syncHandler) GetMetadata(_ context.Context, _ *syncv1.GetMetadataRequest) (
 	*syncv1.GetMetadataResponse, error,
 ) {
+	if s.disableSyncMetadata {
+		return nil, status.Error(codes.Unimplemented, "metadata endpoint disabled")
+	}
 	metadataSrc := make(map[string]any)
 	for k, v := range s.contextValues {
 		metadataSrc[k] = v

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

@@ -54,54 +54,55 @@ func TestSyncHandler_SyncFlags(t *testing.T) {
 		},
 	}
 
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Shared handler for testing both GetMetadata & SyncFlags methods
-			flagStore := store.NewFlags()
-			mp, err := NewMux(flagStore, tt.sources)
-			require.NoError(t, err)
-
-			handler := syncHandler{
-				mux:           mp,
-				contextValues: tt.contextValues,
-				log:           logger.NewLogger(nil, false),
-			}
-
-			// Test getting metadata from `GetMetadata` (deprecated)
-			// remove when `GetMetadata` is full removed and deprecated
-			metaResp, err := handler.GetMetadata(context.Background(), &syncv1.GetMetadataRequest{})
-			require.NoError(t, err)
-			respMetadata := metaResp.GetMetadata().AsMap()
-			assert.Equal(t, tt.wantMetadata, respMetadata)
-
-			// Test metadata from sync_context
-			stream := &mockSyncFlagsServer{
-				ctx:       context.Background(),
-				mu:        sync.Mutex{},
-				respReady: make(chan struct{}, 1),
-			}
-
-			go func() {
-				err := handler.SyncFlags(&syncv1.SyncFlagsRequest{}, stream)
-				assert.NoError(t, err)
-			}()
-
-			select {
-			case <-stream.respReady:
-				syncResp := stream.GetLastResponse()
-				assert.NotNil(t, syncResp)
-
-				syncMetadata := syncResp.GetSyncContext().AsMap()
-				assert.Equal(t, tt.wantMetadata, syncMetadata)
-
-				// Check the two metadatas are equal
+	for _, disableSyncMetadata := range []bool{true, false} {
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				// Shared handler for testing both GetMetadata & SyncFlags methods
+				flagStore := store.NewFlags()
+				mp, err := NewMux(flagStore, tt.sources)
+				require.NoError(t, err)
+
+				handler := syncHandler{
+					mux:                 mp,
+					contextValues:       tt.contextValues,
+					log:                 logger.NewLogger(nil, false),
+					disableSyncMetadata: disableSyncMetadata,
+				}
+
+				// Test getting metadata from `GetMetadata` (deprecated)
 				// remove when `GetMetadata` is full removed and deprecated
-				assert.Equal(t, respMetadata, syncMetadata)
-			case <-time.After(time.Second):
-				t.Fatal("timeout waiting for response")
-			}
-
-		})
+				metaResp, err := handler.GetMetadata(context.Background(), &syncv1.GetMetadataRequest{})
+				if !disableSyncMetadata {
+					require.NoError(t, err)
+					respMetadata := metaResp.GetMetadata().AsMap()
+					assert.Equal(t, tt.wantMetadata, respMetadata)
+				} else {
+					assert.NotNil(t, err)
+				}
+
+				// Test metadata from sync_context
+				stream := &mockSyncFlagsServer{
+					ctx:       context.Background(),
+					mu:        sync.Mutex{},
+					respReady: make(chan struct{}, 1),
+				}
+
+				go func() {
+					err := handler.SyncFlags(&syncv1.SyncFlagsRequest{}, stream)
+					assert.NoError(t, err)
+				}()
+
+				select {
+				case <-stream.respReady:
+					syncResp := stream.GetLastResponse()
+					assert.NotNil(t, syncResp)
+					syncMetadata := syncResp.GetSyncContext().AsMap()
+					assert.Equal(t, tt.wantMetadata, syncMetadata)
+				case <-time.After(time.Second):
+					t.Fatal("timeout waiting for response")
+				}
+			})
+		}
 	}
 }
 

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

@@ -25,15 +25,16 @@ type ISyncService interface {
 }
 
 type SvcConfigurations struct {
-	Logger         *logger.Logger
-	Port           uint16
-	Sources        []string
-	Store          *store.State
-	ContextValues  map[string]any
-	CertPath       string
-	KeyPath        string
-	SocketPath     string
-	StreamDeadline time.Duration
+	Logger              *logger.Logger
+	Port                uint16
+	Sources             []string
+	Store               *store.State
+	ContextValues       map[string]any
+	CertPath            string
+	KeyPath             string
+	SocketPath          string
+	StreamDeadline      time.Duration
+	DisableSyncMetadata bool
 }
 
 type Service struct {
@@ -82,10 +83,11 @@ func NewSyncService(cfg SvcConfigurations) (*Service, error) {
 	}
 
 	syncv1grpc.RegisterFlagSyncServiceServer(server, &syncHandler{
-		mux:           mux,
-		log:           l,
-		contextValues: cfg.ContextValues,
-		deadline:      cfg.StreamDeadline,
+		mux:                 mux,
+		log:                 l,
+		contextValues:       cfg.ContextValues,
+		deadline:            cfg.StreamDeadline,
+		disableSyncMetadata: cfg.DisableSyncMetadata,
 	})
 
 	var lis net.Listener