feat: add single evaluation endpoint for OFREP

go.work.sum

@@ -652,6 +652,7 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20240624140628-dc46fd24d27d/go.
 google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
 google.golang.org/grpc v1.62.1/go.mod h1:IWTG0VlJLCh1SkC58F7np9ka9mx/WNkjl4PGJaiq+QE=
 google.golang.org/grpc v1.63.2/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA=
+google.golang.org/grpc v1.64.0/go.mod h1:oxjF8E3FBnjp+/gVFYdWacaLDx9na1aqy9oovLpxQYg=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.34.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=

internal/cmd/grpc.go

@@ -260,7 +260,7 @@ func NewGRPCServer(
 		evalsrv     = evaluation.New(logger, store)
 		evaldatasrv = evaluationdata.New(logger, store)
 		healthsrv   = health.NewServer()
-		ofrepsrv    = ofrep.New(cfg.Cache)
+		ofrepsrv    = ofrep.New(logger, cfg.Cache, evalsrv)
 	)
 
 	var (

internal/server/evaluation/ofrep_bridge.go

@@ -0,0 +1,90 @@
+package evaluation
+
+import (
+	"context"
+	"errors"
+	"strconv"
+
+	"github.com/google/uuid"
+
+	"go.flipt.io/flipt/internal/server/ofrep"
+
+	rpcevaluation "go.flipt.io/flipt/rpc/flipt/evaluation"
+
+	fliptotel "go.flipt.io/flipt/internal/server/otel"
+	"go.flipt.io/flipt/internal/storage"
+	"go.flipt.io/flipt/rpc/flipt"
+	"go.opentelemetry.io/otel/trace"
+)
+
+const ofrepCtxTargetingKey = "targetingKey"
+
+func (s *Server) OFREPEvaluationBridge(ctx context.Context, input ofrep.EvaluationBridgeInput) (ofrep.EvaluationBridgeOutput, error) {
+	flag, err := s.store.GetFlag(ctx, storage.NewResource(input.NamespaceKey, input.FlagKey))
+	if err != nil {
+		return ofrep.EvaluationBridgeOutput{}, err
+	}
+
+	span := trace.SpanFromContext(ctx)
+	span.SetAttributes(
+		fliptotel.AttributeNamespace.String(input.NamespaceKey),
+		fliptotel.AttributeFlag.String(input.FlagKey),
+		fliptotel.AttributeProviderName,
+	)
+
+	req := &rpcevaluation.EvaluationRequest{
+		NamespaceKey: input.NamespaceKey,
+		FlagKey:      input.FlagKey,
+		EntityId:     uuid.NewString(),
+		Context:      input.Context,
+	}
+
+	// https://openfeature.dev/docs/reference/concepts/evaluation-context/#targeting-key
+	if targetingKey, ok := input.Context[ofrepCtxTargetingKey]; ok {
+		req.EntityId = targetingKey
+	}
+
+	switch flag.Type {
+	case flipt.FlagType_VARIANT_FLAG_TYPE:
+		resp, err := s.variant(ctx, flag, req)
+		if err != nil {
+			return ofrep.EvaluationBridgeOutput{}, err
+		}
+
+		span.SetAttributes(
+			fliptotel.AttributeMatch.Bool(resp.Match),
+			fliptotel.AttributeValue.String(resp.VariantKey),
+			fliptotel.AttributeReason.String(resp.Reason.String()),
+			fliptotel.AttributeSegments.StringSlice(resp.SegmentKeys),
+			fliptotel.AttributeFlagKey(resp.FlagKey),
+			fliptotel.AttributeFlagVariant(resp.VariantKey),
+		)
+
+		return ofrep.EvaluationBridgeOutput{
+			FlagKey: resp.FlagKey,
+			Reason:  resp.Reason,
+			Variant: resp.VariantKey,
+			Value:   resp.VariantKey,
+		}, nil
+	case flipt.FlagType_BOOLEAN_FLAG_TYPE:
+		resp, err := s.boolean(ctx, flag, req)
+		if err != nil {
+			return ofrep.EvaluationBridgeOutput{}, err
+		}
+
+		span.SetAttributes(
+			fliptotel.AttributeValue.Bool(resp.Enabled),
+			fliptotel.AttributeReason.String(resp.Reason.String()),
+			fliptotel.AttributeFlagVariant(strconv.FormatBool(resp.Enabled)),
+		)
+
+		return ofrep.EvaluationBridgeOutput{
+			FlagKey: resp.FlagKey,
+			Variant: strconv.FormatBool(resp.Enabled),
+			Reason:  resp.Reason,
+			Value:   resp.Enabled,
+		}, nil
+	default:
+		return ofrep.EvaluationBridgeOutput{}, errors.New("unsupported flag type for ofrep bridge")
+	}
+}

internal/server/evaluation/ofrep_bridge_test.go

@@ -0,0 +1,106 @@
+package evaluation
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	"go.flipt.io/flipt/internal/server/ofrep"
+	"go.flipt.io/flipt/internal/storage"
+	"go.flipt.io/flipt/rpc/flipt"
+	rpcevaluation "go.flipt.io/flipt/rpc/flipt/evaluation"
+	"go.uber.org/zap/zaptest"
+)
+
+func TestOFREPEvaluationBridge_Variant(t *testing.T) {
+	var (
+		flagKey      = "test-flag"
+		namespaceKey = "test-namespace"
+		store        = &evaluationStoreMock{}
+		logger       = zaptest.NewLogger(t)
+		s            = New(logger, store)
+		flag         = &flipt.Flag{
+			NamespaceKey: namespaceKey,
+			Key:          flagKey,
+			Enabled:      true,
+			Type:         flipt.FlagType_VARIANT_FLAG_TYPE,
+		}
+	)
+
+	store.On("GetFlag", mock.Anything, storage.NewResource(namespaceKey, flagKey)).Return(flag, nil)
+
+	store.On("GetEvaluationRules", mock.Anything, storage.NewResource(namespaceKey, flagKey)).Return([]*storage.EvaluationRule{
+		{
+			ID:      "1",
+			FlagKey: flagKey,
+			Rank:    0,
+			Segments: map[string]*storage.EvaluationSegment{
+				"bar": {
+					SegmentKey: "bar",
+					MatchType:  flipt.MatchType_ANY_MATCH_TYPE,
+				},
+			},
+		},
+	}, nil)
+
+	store.On("GetEvaluationDistributions", mock.Anything, storage.NewID("1")).Return([]*storage.EvaluationDistribution{
+		{
+			ID:         "4",
+			RuleID:     "1",
+			VariantID:  "5",
+			Rollout:    100,
+			VariantKey: "boz",
+		},
+	}, nil)
+
+	output, err := s.OFREPEvaluationBridge(context.TODO(), ofrep.EvaluationBridgeInput{
+		FlagKey:      flagKey,
+		NamespaceKey: namespaceKey,
+		Context: map[string]string{
+			"hello":        "world",
+			"targetingKey": "12345",
+		},
+	})
+	require.NoError(t, err)
+
+	assert.Equal(t, flagKey, output.FlagKey)
+	assert.Equal(t, rpcevaluation.EvaluationReason_MATCH_EVALUATION_REASON, output.Reason)
+	assert.Equal(t, "boz", output.Variant)
+	assert.Equal(t, "boz", output.Value)
+}
+
+func TestOFREPEvaluationBridge_Boolean(t *testing.T) {
+	var (
+		flagKey      = "test-flag"
+		namespaceKey = "test-namespace"
+		store        = &evaluationStoreMock{}
+		logger       = zaptest.NewLogger(t)
+		s            = New(logger, store)
+		flag         = &flipt.Flag{
+			NamespaceKey: namespaceKey,
+			Key:          flagKey,
+			Enabled:      true,
+			Type:         flipt.FlagType_BOOLEAN_FLAG_TYPE,
+		}
+	)
+
+	store.On("GetFlag", mock.Anything, storage.NewResource(namespaceKey, flagKey)).Return(flag, nil)
+
+	store.On("GetEvaluationRollouts", mock.Anything, storage.NewResource(namespaceKey, flagKey)).Return([]*storage.EvaluationRollout{}, nil)
+
+	output, err := s.OFREPEvaluationBridge(context.TODO(), ofrep.EvaluationBridgeInput{
+		FlagKey:      flagKey,
+		NamespaceKey: namespaceKey,
+		Context: map[string]string{
+			"targetingKey": "12345",
+		},
+	})
+	require.NoError(t, err)
+
+	assert.Equal(t, flagKey, output.FlagKey)
+	assert.Equal(t, rpcevaluation.EvaluationReason_DEFAULT_EVALUATION_REASON, output.Reason)
+	assert.Equal(t, "true", output.Variant)
+	assert.Equal(t, true, output.Value)
+}

internal/server/ofrep/bridge_mock.go

@@ -0,0 +1,18 @@
+package ofrep
+
+import (
+	"context"
+
+	"github.com/stretchr/testify/mock"
+)
+
+var _ Bridge = &bridgeMock{}
+
+type bridgeMock struct {
+	mock.Mock
+}
+
+func (b *bridgeMock) OFREPEvaluationBridge(ctx context.Context, input EvaluationBridgeInput) (EvaluationBridgeOutput, error) {
+	args := b.Called(ctx, input)
+	return args.Get(0).(EvaluationBridgeOutput), args.Error(1)
+}

internal/server/ofrep/errors.go

@@ -0,0 +1,88 @@
+package ofrep
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type errorCode string
+
+const (
+	errorCodeFlagNotFound        errorCode = "FLAG_NOT_FOUND"
+	errorCodeParseError          errorCode = "PARSE_ERROR"
+	errorCodeTargetingKeyMissing errorCode = "TARGETING_KEY_MISSING"
+	errorCodeInvalidContext      errorCode = "INVALID_CONTEXT"
+	errorCodeParseGeneral        errorCode = "GENERAL"
+)
+
+type errorSchema struct {
+	Key          string `json:"key,omitempty"`
+	ErrorCode    string `json:"errorCode,omitempty"`
+	ErrorDetails string `json:"errorDetails"`
+}
+
+func NewBadRequestError(key string, err error) error {
+	msg, err := json.Marshal(errorSchema{
+		Key:          key,
+		ErrorCode:    string(errorCodeParseGeneral),
+		ErrorDetails: err.Error(),
+	})
+	if err != nil {
+		return NewInternalServerError(err)
+	}
+
+	return status.Error(codes.InvalidArgument, string(msg))
+}
+
+func NewUnauthenticatedError() error {
+	msg, err := json.Marshal(errorSchema{ErrorDetails: "unauthenticated error"})
+	if err != nil {
+		return NewInternalServerError(err)
+	}
+
+	return status.Error(codes.Unauthenticated, string(msg))
+}
+
+func NewUnauthorizedError() error {
+	msg, err := json.Marshal(errorSchema{ErrorDetails: "unauthorized error"})
+	if err != nil {
+		return NewInternalServerError(err)
+	}
+
+	return status.Error(codes.PermissionDenied, string(msg))
+}
+
+func NewFlagNotFoundError(key string) error {
+	msg, err := json.Marshal(errorSchema{
+		Key:       key,
+		ErrorCode: string(errorCodeFlagNotFound),
+	})
+	if err != nil {
+		return NewInternalServerError(err)
+	}
+
+	return status.Error(codes.NotFound, string(msg))
+}
+
+func NewTargetingKeyMissing() error {
+	msg, err := json.Marshal(errorSchema{
+		ErrorCode:    string(errorCodeTargetingKeyMissing),
+		ErrorDetails: "flag key was not provided",
+	})
+	if err != nil {
+		return NewInternalServerError(err)
+	}
+
+	return status.Error(codes.InvalidArgument, string(msg))
+}
+
+func NewInternalServerError(err error) error {
+	return status.Error(
+		codes.Internal,
+		fmt.Sprintf(`{"errorDetails": "%s"}`, strings.ReplaceAll(err.Error(), `"`, `\"`)),
+	)
+}