FF-3184 feat: add GetJSONBytesAssignment (#69)

* FF-3184 perf: move variation value parsing to precompute phase

* FF-3184 feat: add GetJSONBytesAssignment

---------

Co-authored-by: Leo Romanovsky <[email protected]>

Author: rasendubi

eppoclient/client.go

@@ -90,7 +90,25 @@ func (ec *EppoClient) GetJSONAssignment(flagKey string, subjectKey string, subje
 	if err != nil || variation == nil {
 		return defaultValue, err
 	}
-	return variation, err
+	result, ok := variation.(jsonVariationValue)
+	if !ok {
+		ec.applicationLogger.Errorf("failed to cast %v to json. This should never happen. Please report bug to Eppo", variation)
+		return defaultValue, fmt.Errorf("failed to cast %v to json. This should never happen. Please report bug to Eppo", variation)
+	}
+	return result.Parsed, err
+}
+
+func (ec *EppoClient) GetJSONBytesAssignment(flagKey string, subjectKey string, subjectAttributes Attributes, defaultValue []byte) ([]byte, error) {
+	variation, err := ec.getAssignment(ec.configurationStore.getConfiguration(), flagKey, subjectKey, subjectAttributes, jsonVariation)
+	if err != nil || variation == nil {
+		return defaultValue, err
+	}
+	result, ok := variation.(jsonVariationValue)
+	if !ok {
+		ec.applicationLogger.Errorf("failed to cast %v to json. This should never happen. Please report bug to Eppo", variation)
+		return defaultValue, fmt.Errorf("failed to cast %v to json. This should never happen. Please report bug to Eppo", variation)
+	}
+	return result.Raw, err
 }
 
 type BanditResult struct {

eppoclient/client_test.go

@@ -58,16 +58,16 @@ func Test_LogAssignment(t *testing.T) {
 			mockLogger.Mock.On("LogAssignment", mock.Anything).Return()
 
 			config := configResponse{
-				Flags: map[string]flagConfiguration{
-					"experiment-key-1": flagConfiguration{
+				Flags: map[string]*flagConfiguration{
+					"experiment-key-1": &flagConfiguration{
 						Key:           "experiment-key-1",
 						Enabled:       true,
 						TotalShards:   10000,
 						VariationType: stringVariation,
 						Variations: map[string]variation{
 							"control": variation{
 								Key:   "control",
-								Value: "control",
+								Value: []byte("\"control\""),
 							},
 						},
 						Allocations: []allocation{
@@ -158,16 +158,16 @@ func Test_GetStringAssignmentHandlesLoggingPanic(t *testing.T) {
 	var mockLogger = new(mockLogger)
 	mockLogger.Mock.On("LogAssignment", mock.Anything).Panic("logging panic")
 
-	config := configResponse{Flags: map[string]flagConfiguration{
-		"experiment-key-1": flagConfiguration{
+	config := configResponse{Flags: map[string]*flagConfiguration{
+		"experiment-key-1": &flagConfiguration{
 			Key:           "experiment-key-1",
 			Enabled:       true,
 			TotalShards:   10000,
 			VariationType: stringVariation,
 			Variations: map[string]variation{
 				"control": variation{
 					Key:   "control",
-					Value: "control",
+					Value: []byte("\"control\""),
 				},
 			},
 			Allocations: []allocation{

eppoclient/configresponse.go

@@ -9,8 +9,14 @@ import (
 )
 
 type configResponse struct {
-	Flags   map[string]flagConfiguration `json:"flags"`
-	Bandits map[string][]banditVariation `json:"bandits,omitempty"`
+	Flags   map[string]*flagConfiguration `json:"flags"`
+	Bandits map[string][]banditVariation  `json:"bandits,omitempty"`
+}
+
+func (response *configResponse) precompute() {
+	for i := range response.Flags {
+		response.Flags[i].precompute()
+	}
 }
 
 type flagConfiguration struct {
@@ -20,17 +26,39 @@ type flagConfiguration struct {
 	Variations    map[string]variation `json:"variations"`
 	Allocations   []allocation         `json:"allocations"`
 	TotalShards   int64                `json:"totalShards"`
-}
-
-func (flag *flagConfiguration) Precompute() {
+	// Cached Variations parsed according to `VariationType`.
+	//
+	// Types are as follows:
+	// - STRING -> string
+	// - NUMERIC -> float64
+	// - INTEGER -> int64
+	// - BOOLEAN -> bool
+	// - JSON -> jsonVariationValue
+	ParsedVariations map[string]interface{} `json:"-"`
+}
+
+func (flag *flagConfiguration) precompute() {
 	for i := range flag.Allocations {
-		flag.Allocations[i].Precompute()
+		flag.Allocations[i].precompute()
+	}
+
+	flag.ParsedVariations = make(map[string]interface{}, len(flag.Variations))
+	for i := range flag.Variations {
+		value, err := flag.VariationType.parseVariationValue(flag.Variations[i].Value)
+		if err == nil {
+			flag.ParsedVariations[i] = value
+		}
 	}
 }
 
 type variation struct {
-	Key   string      `json:"key"`
-	Value interface{} `json:"value"`
+	Key   string          `json:"key"`
+	Value json.RawMessage `json:"value"`
+}
+
+type jsonVariationValue struct {
+	Raw    []byte
+	Parsed interface{}
 }
 
 type variationType int
@@ -84,33 +112,52 @@ func (v *variationType) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-func (ty variationType) valueToAssignmentValue(value interface{}) (interface{}, error) {
+func (ty variationType) parseVariationValue(value json.RawMessage) (interface{}, error) {
 	switch ty {
 	case stringVariation:
-		s := value.(string)
+		var s string
+		err := json.Unmarshal(value, &s)
+		if err != nil {
+			return nil, err
+		}
 		return s, nil
 	case integerVariation:
-		f64 := value.(float64)
-		i64 := int64(f64)
-		if f64 == float64(i64) {
-			return i64, nil
-		} else {
-			return nil, fmt.Errorf("failed to convert number to integer")
+		var i int64
+		err := json.Unmarshal(value, &i)
+		if err != nil {
+			return nil, err
 		}
+		return i, nil
 	case numericVariation:
-		number := value.(float64)
-		return number, nil
+		var f float64
+		err := json.Unmarshal(value, &f)
+		if err != nil {
+			return nil, err
+		}
+		return f, nil
 	case booleanVariation:
-		v := value.(bool)
-		return v, nil
+		var b bool
+		err := json.Unmarshal(value, &b)
+		if err != nil {
+			return nil, err
+		}
+		return b, nil
 	case jsonVariation:
-		v := value.(string)
-		var result interface{}
-		err := json.Unmarshal([]byte(v), &result)
+		var s string
+		err := json.Unmarshal(value, &s)
 		if err != nil {
 			return nil, err
 		}
-		return result, nil
+
+		raw := []byte(s)
+
+		var parsed interface{}
+		err = json.Unmarshal(raw, &parsed)
+		if err != nil {
+			return nil, err
+		}
+
+		return jsonVariationValue{raw, parsed}, nil
 	default:
 		return nil, fmt.Errorf("unexpected variation type: %v", ty)
 	}
@@ -125,19 +172,19 @@ type allocation struct {
 	DoLog   *bool     `json:"doLog"`
 }
 
-func (a *allocation) Precompute() {
+func (a *allocation) precompute() {
 	for i := range a.Rules {
-		a.Rules[i].Precompute()
+		a.Rules[i].precompute()
 	}
 }
 
 type rule struct {
 	Conditions []condition `json:"conditions"`
 }
 
-func (r *rule) Precompute() {
+func (r *rule) precompute() {
 	for i := range r.Conditions {
-		r.Conditions[i].Precompute()
+		r.Conditions[i].precompute()
 	}
 }
 
@@ -152,7 +199,7 @@ type condition struct {
 	SemVerValueValid  bool
 }
 
-func (c *condition) Precompute() {
+func (c *condition) precompute() {
 	// Try to convert Value to a float64
 	if num, err := toFloat64(c.Value); err == nil {
 		c.NumericValue = num

eppoclient/configurationrequestor.go

@@ -65,11 +65,6 @@ func (cr *configurationRequestor) fetchConfig() (configResponse, error) {
 		return configResponse{}, err
 	}
 
-	// Precompute flag values
-	for _, flag := range response.Flags {
-		flag.Precompute()
-	}
-
 	return response, nil
 }
 

eppoclient/configurationstore.go

@@ -14,9 +14,11 @@ type configuration struct {
 	banditFlagAssociations map[string]map[string]banditVariation
 }
 
-func (c *configuration) refreshBanditFlagAssociations() {
+func (c *configuration) precompute() {
 	associations := make(map[string]map[string]banditVariation)
 
+	c.flags.precompute()
+
 	for _, banditVariations := range c.flags.Bandits {
 		for _, bandit := range banditVariations {
 			byVariation, ok := associations[bandit.FlagKey]
@@ -40,10 +42,10 @@ func (c configuration) getBanditVariant(flagKey, variation string) (result bandi
 	return result, ok
 }
 
-func (c configuration) getFlagConfiguration(key string) (flagConfiguration, error) {
+func (c configuration) getFlagConfiguration(key string) (*flagConfiguration, error) {
 	flag, ok := c.flags.Flags[key]
 	if !ok {
-		return flag, ErrFlagConfigurationNotFound
+		return nil, ErrFlagConfigurationNotFound
 	}
 
 	return flag, nil
@@ -78,6 +80,6 @@ func (cs *configurationStore) getConfiguration() configuration {
 }
 
 func (cs *configurationStore) setConfiguration(configuration configuration) {
-	configuration.refreshBanditFlagAssociations()
+	configuration.precompute()
 	cs.configuration.Store(&configuration)
 }

eppoclient/configurationstore_test.go

@@ -13,13 +13,13 @@ func Test_GetConfiguration_unknownKey(t *testing.T) {
 	result, err := config.getFlagConfiguration("unknown_exp")
 
 	assert.Error(t, err)
-	assert.Equal(t, flagConfiguration{}, result)
+	assert.Nil(t, result)
 }
 
 func Test_GetConfiguration_knownKey(t *testing.T) {
 	flags := configResponse{
-		Flags: map[string]flagConfiguration{
-			"experiment-key-1": flagConfiguration{
+		Flags: map[string]*flagConfiguration{
+			"experiment-key-1": &flagConfiguration{
 				Key:           "experiment-key-1",
 				Enabled:       false,
 				VariationType: stringVariation,

eppoclient/eppoclient_e2e_test.go

@@ -60,6 +60,14 @@ func Test_e2e(t *testing.T) {
 					case jsonVariation:
 						value, _ := client.GetJSONAssignment(test.Flag, subject.SubjectKey, subject.SubjectAttributes, test.DefaultValue)
 						assert.Equal(t, subject.Assignment, value)
+
+						// Convert DefaultValue to []byte for GetJSONBytesAssignment
+						defaultValueBytes, _ := json.Marshal(test.DefaultValue)
+						valueBytes, _ := client.GetJSONBytesAssignment(test.Flag, subject.SubjectKey, subject.SubjectAttributes, defaultValueBytes)
+
+						var parsedValueBytes interface{}
+						_ = json.Unmarshal(valueBytes, &parsedValueBytes)
+						assert.Equal(t, subject.Assignment, parsedValueBytes)
 					case stringVariation:
 						value, _ := client.GetStringAssignment(test.Flag, subject.SubjectKey, subject.SubjectAttributes, test.DefaultValue.(string))
 						assert.Equal(t, subject.Assignment, value)

eppoclient/evalflags.go

@@ -34,23 +34,18 @@ func (flag flagConfiguration) eval(subjectKey string, subjectAttributes Attribut
 		return nil, nil, ErrSubjectAllocation
 	}
 
-	variation, ok := flag.Variations[split.VariationKey]
+	assignmentValue, ok := flag.ParsedVariations[split.VariationKey]
 	if !ok {
 		return nil, nil, fmt.Errorf("cannot find variation: %v", split.VariationKey)
 	}
 
-	assignmentValue, err := flag.VariationType.valueToAssignmentValue(variation.Value)
-	if err != nil {
-		return nil, nil, err
-	}
-
 	var assignmentEvent *AssignmentEvent
 	if allocation.DoLog == nil || *allocation.DoLog {
 		assignmentEvent = &AssignmentEvent{
 			FeatureFlag:       flag.Key,
 			Allocation:        allocation.Key,
 			Experiment:        flag.Key + "-" + allocation.Key,
-			Variation:         variation.Key,
+			Variation:         split.VariationKey,
 			Subject:           subjectKey,
 			SubjectAttributes: subjectAttributes,
 			Timestamp:         now.UTC().Format(time.RFC3339),

eppoclient/rules_test.go

@@ -24,9 +24,9 @@ var textRule = rule{Conditions: []condition{
 var ruleWithEmptyConditions = rule{Conditions: []condition{}}
 
 func init() {
-	numericRule.Precompute()
-	semverRule.Precompute()
-	textRule.Precompute()
+	numericRule.precompute()
+	semverRule.precompute()
+	textRule.precompute()
 }
 
 func Test_TextRule_NoMatch(t *testing.T) {
@@ -292,7 +292,7 @@ func Test_isNotNull_attributePresent(t *testing.T) {
 
 func Test_handles_all_numeric_types(t *testing.T) {
 	condition := condition{Operator: "GT", Attribute: "powerLevel", Value: "9000"}
-	condition.Precompute()
+	condition.precompute()
 
 	// Floats
 	assert.True(t, condition.matches(Attributes{"powerLevel": 9001.0}))
@@ -328,7 +328,7 @@ func Test_handles_all_numeric_types(t *testing.T) {
 
 func Test_invalid_numeric_types(t *testing.T) {
 	condition := condition{Operator: "GT", Attribute: "powerLevel", Value: "9000"}
-	condition.Precompute()
+	condition.precompute()
 
 	assert.False(t, condition.matches(Attributes{"powerLevel": "empty"}))
 	assert.False(t, condition.matches(Attributes{"powerLevel": ""}))

eppoclient/ufc_test.go

@@ -46,7 +46,7 @@ func TestConditionPrecompute(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			tc.condition.Precompute()
+			tc.condition.precompute()
 			assert.Equal(t, tc.expectedNumVal, tc.condition.NumericValue)
 			assert.Equal(t, tc.expectedNumValValid, tc.condition.NumericValueValid)
 			assert.Equal(t, tc.expectedSemVerVal, tc.condition.SemVerValue)