use feature flags

Signed-off-by: Shijie Sheng <liouvetren@gmail.com>

Author: shijiesheng

common/headers.go

@@ -59,7 +59,4 @@ const (
 
 	// CallerTypeHeaderName refers to the name of the header that contains the caller type (CLI, UI, SDK, internal, etc.)
 	CallerTypeHeaderName = types.CallerTypeHeaderName
-
-	// QueryConsistencyLevelHeaderName refers to the name of the header that contains the query consistency level (EVENTUAL, STRONG)
-	QueryConsistencyLevelHeaderName = "cadence-query-consistency-level"
 )

common/rpc/middleware.go

@@ -38,8 +38,6 @@ import (
 	"github.com/uber/cadence/common/types"
 )
 
-var _ middleware.UnaryInbound = &QueryConsistencyLevelInboundMiddleware{}
-
 type authOutboundMiddleware struct {
 	authProvider worker.AuthorizationProvider
 }
@@ -266,18 +264,3 @@ func (m *ClientPartitionConfigMiddleware) Handle(ctx context.Context, req *trans
 	}
 	return h.Handle(ctx, req, resw)
 }
-
-type QueryConsistencyLevelInboundMiddleware struct{}
-
-func (m *QueryConsistencyLevelInboundMiddleware) Handle(ctx context.Context, req *transport.Request, resw transport.ResponseWriter, h transport.UnaryHandler) error {
-	queryConsistencyLevel, ok := req.Headers.Get(common.QueryConsistencyLevelHeaderName)
-	if ok {
-		var level types.QueryConsistencyLevel
-		err := level.UnmarshalText([]byte(queryConsistencyLevel))
-		if err != nil {
-			return fmt.Errorf("failed to parse query consistency level: %w", err)
-		}
-		ctx = context.WithValue(ctx, common.QueryConsistencyLevelHeaderName, level)
-	}
-	return h.Handle(ctx, req, resw)
-}

common/rpc/middleware_test.go

@@ -381,99 +381,6 @@ func TestCallerInfoMiddleware(t *testing.T) {
 	})
 }
 
-func TestQueryConsistencyLevelInboundMiddleware(t *testing.T) {
-	tests := []struct {
-		name          string
-		headerValue   string
-		hasHeader     bool
-		expectedLevel types.QueryConsistencyLevel
-		expectError   bool
-	}{
-		{
-			name:          "parses EVENTUAL consistency level",
-			headerValue:   "EVENTUAL",
-			hasHeader:     true,
-			expectedLevel: types.QueryConsistencyLevelEventual,
-			expectError:   false,
-		},
-		{
-			name:          "parses STRONG consistency level",
-			headerValue:   "STRONG",
-			hasHeader:     true,
-			expectedLevel: types.QueryConsistencyLevelStrong,
-			expectError:   false,
-		},
-		{
-			name:          "parses lowercase eventual",
-			headerValue:   "eventual",
-			hasHeader:     true,
-			expectedLevel: types.QueryConsistencyLevelEventual,
-			expectError:   false,
-		},
-		{
-			name:          "parses lowercase strong",
-			headerValue:   "strong",
-			hasHeader:     true,
-			expectedLevel: types.QueryConsistencyLevelStrong,
-			expectError:   false,
-		},
-		{
-			name:          "parses numeric value 0",
-			headerValue:   "0",
-			hasHeader:     true,
-			expectedLevel: types.QueryConsistencyLevelEventual,
-			expectError:   false,
-		},
-		{
-			name:          "parses numeric value 1",
-			headerValue:   "1",
-			hasHeader:     true,
-			expectedLevel: types.QueryConsistencyLevelStrong,
-			expectError:   false,
-		},
-		{
-			name:        "returns error for invalid value",
-			headerValue: "INVALID",
-			hasHeader:   true,
-			expectError: true,
-		},
-		{
-			name:        "no header - noop",
-			hasHeader:   false,
-			expectError: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &QueryConsistencyLevelInboundMiddleware{}
-			h := &fakeHandler{}
-			headers := transport.NewHeaders()
-			if tt.hasHeader {
-				headers = headers.With(common.QueryConsistencyLevelHeaderName, tt.headerValue)
-			}
-
-			err := m.Handle(context.Background(), &transport.Request{Headers: headers}, nil, h)
-
-			if tt.expectError {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), "failed to parse query consistency level")
-				return
-			}
-
-			assert.NoError(t, err)
-			if tt.hasHeader {
-				level, ok := h.ctx.Value(common.QueryConsistencyLevelHeaderName).(types.QueryConsistencyLevel)
-				assert.True(t, ok, "expected query consistency level to be set in context")
-				assert.Equal(t, tt.expectedLevel, level)
-			} else {
-				// When no header is present, context value should not be set
-				assert.Nil(t, h.ctx.Value(common.QueryConsistencyLevelHeaderName))
-			}
-		})
-	}
-}
-
 func TestCallerInfoOutboundMiddleware(t *testing.T) {
 	t.Run("sets internal caller type when no inbound call and header is missing", func(t *testing.T) {
 		m := &CallerInfoOutboundMiddleware{}

common/rpc/params.go

@@ -170,7 +170,7 @@ func NewParams(serviceName string, config *config.Config, dc *dynamicconfig.Coll
 		OutboundTLS:      outboundTLS,
 		InboundMiddleware: yarpc.InboundMiddleware{
 			// order matters: ForwardPartitionConfigMiddleware must be applied after ClientPartitionConfigMiddleware
-			Unary: yarpc.UnaryInboundMiddleware(&InboundMetricsMiddleware{}, &CallerInfoMiddleware{}, &ClientPartitionConfigMiddleware{}, &ForwardPartitionConfigMiddleware{}, &QueryConsistencyLevelInboundMiddleware{}),
+			Unary: yarpc.UnaryInboundMiddleware(&InboundMetricsMiddleware{}, &CallerInfoMiddleware{}, &ClientPartitionConfigMiddleware{}, &ForwardPartitionConfigMiddleware{}),
 		},
 		OutboundMiddleware: yarpc.OutboundMiddleware{
 			Unary: yarpc.UnaryOutboundMiddleware(&HeaderForwardingMiddleware{

host/onebox.go

@@ -1159,7 +1159,7 @@ func (c *cadenceImpl) newRPCFactory(serviceName string, host membership.HostInfo
 		TChannelAddress: tchannelAddress,
 		GRPCAddress:     grpcAddress,
 		InboundMiddleware: yarpc.InboundMiddleware{
-			Unary: yarpc.UnaryInboundMiddleware(&versionMiddleware{}, &rpc.ClientPartitionConfigMiddleware{}, &rpc.ForwardPartitionConfigMiddleware{}, &rpc.QueryConsistencyLevelInboundMiddleware{}),
+			Unary: yarpc.UnaryInboundMiddleware(&versionMiddleware{}, &rpc.ClientPartitionConfigMiddleware{}, &rpc.ForwardPartitionConfigMiddleware{}),
 		},
 		OutboundMiddleware: yarpc.OutboundMiddleware{
 			Unary: &rpc.ForwardPartitionConfigMiddleware{},

service/frontend/wrappers/clusterredirection/utils.go

@@ -3,14 +3,16 @@ package clusterredirection
 import (
 	"context"
 
-	"github.com/uber/cadence/common"
+	"github.com/uber/cadence/common/client"
 	"github.com/uber/cadence/common/types"
+	"go.uber.org/yarpc"
 )
 
 func getRequestedConsistencyLevelFromContext(ctx context.Context) types.QueryConsistencyLevel {
-	requestedConsistencyLevelFromCtx, ok := ctx.Value(common.QueryConsistencyLevelHeaderName).(types.QueryConsistencyLevel)
-	if ok {
-		return requestedConsistencyLevelFromCtx
+	call := yarpc.CallFromContext(ctx)
+	featureFlags := client.GetFeatureFlagsFromHeader(call)
+	if featureFlags.AutoforwardingEnabled {
+		return types.QueryConsistencyLevelStrong
 	}
 	return types.QueryConsistencyLevelEventual
 }