Added evaluation options for treatments

Author: nmayorsplit

go.mod

@@ -3,7 +3,7 @@ module github.com/splitio/go-client/v6
 go 1.18
 
 require (
-	github.com/splitio/go-split-commons/v9 v9.0.0
+	github.com/splitio/go-split-commons/v9 v9.0.1-0.20251202184315-69a1a4a8c150
 	github.com/splitio/go-toolkit/v5 v5.4.1
 	github.com/stretchr/testify v1.11.1
 )

go.sum

@@ -21,8 +21,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/redis/go-redis/v9 v9.0.4 h1:FC82T+CHJ/Q/PdyLW++GeCO+Ol59Y4T7R4jbgjvktgc=
 github.com/redis/go-redis/v9 v9.0.4/go.mod h1:WqMKv5vnQbRuZstUwxQI195wHy+t4PuXDOjzMvcuQHk=
-github.com/splitio/go-split-commons/v9 v9.0.0 h1:6uHEkBMUUZNhIiop9dyN04gXQUrMXp+X/0uXSytbp+Q=
-github.com/splitio/go-split-commons/v9 v9.0.0/go.mod h1:gJuaKo04Swlh4w9C1b2jBAqAdFxEd/Vpd8jnFINOeDY=
+github.com/splitio/go-split-commons/v9 v9.0.1-0.20251202184315-69a1a4a8c150 h1:rfNMXpXAKXzqM76WNuh+IKNGZ1LBwlyYXAx84tZMw80=
+github.com/splitio/go-split-commons/v9 v9.0.1-0.20251202184315-69a1a4a8c150/go.mod h1:gJuaKo04Swlh4w9C1b2jBAqAdFxEd/Vpd8jnFINOeDY=
 github.com/splitio/go-toolkit/v5 v5.4.1 h1:srTyvDBJZMUcJ/KiiQDMyjCuELVgTBh2TGRVn0sOXEE=
 github.com/splitio/go-toolkit/v5 v5.4.1/go.mod h1:SifzysrOVDbzMcOE8zjX02+FG5az4FrR3Us/i5SeStw=
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=

splitio/client/client.go

@@ -1,6 +1,7 @@
 package client
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"runtime/debug"
@@ -22,14 +23,22 @@ import (
 )
 
 const (
-	treatment                      = "Treatment"
-	treatments                     = "Treatments"
-	treatmentsByFlagSet            = "TreatmentsByFlagSet"
-	treatmentsByFlagSets           = "TreatmentsByFlagSets"
-	treatmentWithConfig            = "TreatmentWithConfig"
-	treatmentsWithConfig           = "TreatmentsWithConfig"
-	treatmentsWithConfigByFlagSet  = "TreatmentsWithConfigByFlagSet"
-	treatmentsWithConfigByFlagSets = "TreatmentsWithConfigByFlagSets"
+	treatment                                          = "Treatment"
+	treatments                                         = "Treatments"
+	treatmentsByFlagSet                                = "TreatmentsByFlagSet"
+	treatmentsByFlagSets                               = "TreatmentsByFlagSets"
+	treatmentWithConfig                                = "TreatmentWithConfig"
+	treatmentsWithConfig                               = "TreatmentsWithConfig"
+	treatmentsWithConfigByFlagSet                      = "TreatmentsWithConfigByFlagSet"
+	treatmentsWithConfigByFlagSets                     = "TreatmentsWithConfigByFlagSets"
+	treatmentWithEvaluationOptions                     = "TreatmentWithEvaluationOptions"
+	treatmentsWithEvaluationOptions                    = "TreatmentsWithEvaluationOptions"
+	treatmentsByFlagSetWithEvaluationOptions           = "TreatmentsByFlagSetWithEvaluationOptions"
+	treatmentsByFlagSetsWithEvaluationOptions          = "TreatmentsByFlagSetsWithEvaluationOptions"
+	treatmentWithConfigAndEvaluationOptions            = "TreatmentWithConfigWithEvaluationOptions"
+	treatmentsWithConfigAndEvaluationOptions           = "TreatmentsWithConfigWithEvaluationOptions"
+	treatmentsWithConfigByFlagSetAndEvaluationOptions  = "TreatmentsWithConfigByFlagSetWithEvaluationOptions"
+	treatmentsWithConfigByFlagSetsAndEvaluationOptions = "TreatmentsWithConfigByFlagSetsWithEvaluationOptions"
 )
 
 // SplitClient is the entry-point of the split SDK.
@@ -95,7 +104,7 @@ func (c *SplitClient) getEvaluationsResult(matchingKey string, bucketingKey *str
 }
 
 // createImpression creates impression to be stored and used by listener
-func (c *SplitClient) createImpression(featureFlag string, bucketingKey *string, evaluationLabel string, matchingKey string, treatment string, changeNumber int64, disabled bool) dtos.Impression {
+func (c *SplitClient) createImpression(featureFlag string, bucketingKey *string, evaluationLabel string, matchingKey string, treatment string, changeNumber int64, disabled bool, properties string) dtos.Impression {
 	var label string
 	if c.factory.cfg.LabelsEnabled {
 		label = evaluationLabel
@@ -115,6 +124,7 @@ func (c *SplitClient) createImpression(featureFlag string, bucketingKey *string,
 		Treatment:    treatment,
 		Time:         time.Now().UTC().UnixNano() / int64(time.Millisecond), // Convert standard timestamp to java's ms timestamps
 		Disabled:     disabled,
+		Properties:   properties,
 	}
 }
 
@@ -140,7 +150,7 @@ func (c *SplitClient) storeData(impressions []dtos.Impression, attributes map[st
 }
 
 // doTreatmentCall retrieves treatments of an specific feature flag with configurations object if it is present for a certain key and set of attributes
-func (c *SplitClient) doTreatmentCall(key interface{}, featureFlag string, attributes map[string]interface{}, operation string, metricsLabel string) (t TreatmentResult) {
+func (c *SplitClient) doTreatmentCall(key interface{}, featureFlag string, attributes map[string]interface{}, operation string, metricsLabel string, evaluationOptions *dtos.EvaluationOptions) (t TreatmentResult) {
 	controlTreatment := TreatmentResult{
 		Treatment: evaluator.Control,
 		Config:    nil,
@@ -184,7 +194,7 @@ func (c *SplitClient) doTreatmentCall(key interface{}, featureFlag string, attri
 	}
 
 	c.storeData(
-		[]dtos.Impression{c.createImpression(featureFlag, bucketingKey, evaluationResult.Label, matchingKey, evaluationResult.Treatment, evaluationResult.SplitChangeNumber, evaluationResult.ImpressionsDisabled)},
+		[]dtos.Impression{c.createImpression(featureFlag, bucketingKey, evaluationResult.Label, matchingKey, evaluationResult.Treatment, evaluationResult.SplitChangeNumber, evaluationResult.ImpressionsDisabled, serializeProperties(evaluationOptions))},
 		attributes,
 		metricsLabel,
 		evaluationResult.EvaluationTime,
@@ -196,16 +206,44 @@ func (c *SplitClient) doTreatmentCall(key interface{}, featureFlag string, attri
 	}
 }
 
+func serializeProperties(opts *dtos.EvaluationOptions) string {
+	if opts == nil {
+		return ""
+	}
+	if len(opts.Properties) == 0 {
+		return ""
+	}
+
+	properties, err := json.Marshal(opts.Properties)
+	if err != nil {
+		return ""
+	}
+
+	return string(properties)
+}
+
 // Treatment implements the main functionality of split. Retrieve treatments of a specific feature flag
 // for a certain key and set of attributes
 func (c *SplitClient) Treatment(key interface{}, featureFlagName string, attributes map[string]interface{}) string {
-	return c.doTreatmentCall(key, featureFlagName, attributes, treatment, telemetry.Treatment).Treatment
+	return c.doTreatmentCall(key, featureFlagName, attributes, treatment, telemetry.Treatment, nil).Treatment
 }
 
 // TreatmentWithConfig implements the main functionality of split. Retrieves the treatment of a specific feature flag
 // with the corresponding configuration if it is present
 func (c *SplitClient) TreatmentWithConfig(key interface{}, featureFlagName string, attributes map[string]interface{}) TreatmentResult {
-	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithConfig, telemetry.TreatmentWithConfig)
+	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithConfig, telemetry.TreatmentWithConfig, nil)
+}
+
+// TreatmentWithEvaluationOptions implements the main functionality of split. Retrieve treatments of a specific feature flag
+// for a certain key and set of attributes
+func (c *SplitClient) TreatmentWithEvaluationOptions(key interface{}, featureFlagName string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) string {
+	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithEvaluationOptions, telemetry.TreatmentWithEvaluationOptions, &evaluationOptions).Treatment
+}
+
+// TreatmentWithConfigAndEvaluationOptions implements the main functionality of split. Retrieves the treatment of a specific feature flag
+// with the corresponding configuration if it is present
+func (c *SplitClient) TreatmentWithConfigAndEvaluationOptions(key interface{}, featureFlagName string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) TreatmentResult {
+	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithConfigAndEvaluationOptions, telemetry.TreatmentWithConfigAndEvaluationOptions, &evaluationOptions)
 }
 
 // Generates control treatments
@@ -224,7 +262,7 @@ func (c *SplitClient) generateControlTreatments(featureFlagNames []string, opera
 	return treatments
 }
 
-func (c *SplitClient) processResult(result evaluator.Results, operation string, bucketingKey *string, matchingKey string, attributes map[string]interface{}, metricsLabel string) (t map[string]TreatmentResult) {
+func (c *SplitClient) processResult(result evaluator.Results, operation string, bucketingKey *string, matchingKey string, attributes map[string]interface{}, metricsLabel string, evaluationOptions *dtos.EvaluationOptions) (t map[string]TreatmentResult) {
 	var bulkImpressions []dtos.Impression
 	treatments := make(map[string]TreatmentResult)
 	for feature, evaluation := range result.Evaluations {
@@ -234,7 +272,8 @@ func (c *SplitClient) processResult(result evaluator.Results, operation string,
 				Config:    nil,
 			}
 		} else {
-			bulkImpressions = append(bulkImpressions, c.createImpression(feature, bucketingKey, evaluation.Label, matchingKey, evaluation.Treatment, evaluation.SplitChangeNumber, evaluation.ImpressionsDisabled))
+			bulkImpressions = append(bulkImpressions, c.createImpression(feature, bucketingKey, evaluation.Label, matchingKey, evaluation.Treatment, evaluation.SplitChangeNumber, evaluation.ImpressionsDisabled, serializeProperties(evaluationOptions)))
+			//bulkImpressions = append(bulkImpressions, c.createImpression(feature, bucketingKey, evaluation.Label, matchingKey, evaluation.Treatment, evaluation.SplitChangeNumber, evaluation.ImpressionsDisabled, ""))
 
 			treatments[feature] = TreatmentResult{
 				Treatment: evaluation.Treatment,
@@ -247,7 +286,7 @@ func (c *SplitClient) processResult(result evaluator.Results, operation string,
 }
 
 // doTreatmentsCall retrieves treatments of an specific array of feature flag names with configurations object if it is present for a certain key and set of attributes
-func (c *SplitClient) doTreatmentsCall(key interface{}, featureFlagNames []string, attributes map[string]interface{}, operation string, metricsLabel string) (t map[string]TreatmentResult) {
+func (c *SplitClient) doTreatmentsCall(key interface{}, featureFlagNames []string, attributes map[string]interface{}, operation string, metricsLabel string, evaluationOptions *dtos.EvaluationOptions) (t map[string]TreatmentResult) {
 	// Set up a guard deferred function to recover if the SDK starts panicking
 	defer func() {
 		if r := recover(); r != nil {
@@ -280,11 +319,11 @@ func (c *SplitClient) doTreatmentsCall(key interface{}, featureFlagNames []strin
 
 	evaluationsResult := c.getEvaluationsResult(matchingKey, bucketingKey, filteredFeatures, attributes, operation)
 
-	return c.processResult(evaluationsResult, operation, bucketingKey, matchingKey, attributes, metricsLabel)
+	return c.processResult(evaluationsResult, operation, bucketingKey, matchingKey, attributes, metricsLabel, evaluationOptions)
 }
 
 // doTreatmentsCallByFlagSets retrieves treatments of a specific array of feature flag names, that belong to flag sets, with configurations object if it is present for a certain key and set of attributes
-func (c *SplitClient) doTreatmentsCallByFlagSets(key interface{}, flagSets []string, attributes map[string]interface{}, operation string, metricsLabel string) (t map[string]TreatmentResult) {
+func (c *SplitClient) doTreatmentsCallByFlagSets(key interface{}, flagSets []string, attributes map[string]interface{}, operation string, metricsLabel string, evaluationOptions *dtos.EvaluationOptions) (t map[string]TreatmentResult) {
 	treatments := make(map[string]TreatmentResult)
 
 	// Set up a guard deferred function to recover if the SDK starts panicking
@@ -312,15 +351,25 @@ func (c *SplitClient) doTreatmentsCallByFlagSets(key interface{}, flagSets []str
 
 	if c.isReady() {
 		evaluationsResult := c.evaluator.EvaluateFeatureByFlagSets(matchingKey, bucketingKey, flagSets, attributes)
-		treatments = c.processResult(evaluationsResult, operation, bucketingKey, matchingKey, attributes, metricsLabel)
+		treatments = c.processResult(evaluationsResult, operation, bucketingKey, matchingKey, attributes, metricsLabel, evaluationOptions)
 	}
 	return treatments
 }
 
 // Treatments evaluates multiple feature flag names for a single user and set of attributes at once
 func (c *SplitClient) Treatments(key interface{}, featureFlagNames []string, attributes map[string]interface{}) map[string]string {
 	treatmentsResult := map[string]string{}
-	result := c.doTreatmentsCall(key, featureFlagNames, attributes, treatments, telemetry.Treatments)
+	result := c.doTreatmentsCall(key, featureFlagNames, attributes, treatments, telemetry.Treatments, nil)
+	for feature, treatmentResult := range result {
+		treatmentsResult[feature] = treatmentResult.Treatment
+	}
+	return treatmentsResult
+}
+
+// TreatmentsWithEvaluationOptions evaluates multiple feature flag names for a single user and set of attributes at once
+func (c *SplitClient) TreatmentsWithEvaluationOptions(key interface{}, featureFlagNames []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]string {
+	treatmentsResult := map[string]string{}
+	result := c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithEvaluationOptions, telemetry.TreatmentsWithEvaluationOptions, &evaluationOptions)
 	for feature, treatmentResult := range result {
 		treatmentsResult[feature] = treatmentResult.Treatment
 	}
@@ -354,7 +403,7 @@ func (c *SplitClient) TreatmentsByFlagSet(key interface{}, flagSet string, attri
 	if sets == nil {
 		return treatmentsResult
 	}
-	result := c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsByFlagSet, telemetry.TreatmentsByFlagSet)
+	result := c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsByFlagSet, telemetry.TreatmentsByFlagSet, nil)
 	for feature, treatmentResult := range result {
 		treatmentsResult[feature] = treatmentResult.Treatment
 	}
@@ -368,7 +417,35 @@ func (c *SplitClient) TreatmentsByFlagSets(key interface{}, flagSets []string, a
 	if flagSets == nil {
 		return treatmentsResult
 	}
-	result := c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsByFlagSets, telemetry.TreatmentsByFlagSets)
+	result := c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsByFlagSets, telemetry.TreatmentsByFlagSets, nil)
+	for feature, treatmentResult := range result {
+		treatmentsResult[feature] = treatmentResult.Treatment
+	}
+	return treatmentsResult
+}
+
+// TreatmentsByFlagSetWithEvaluationOptions evaluate multiple feature flag names belonging to a flag set for a single user and a set of attributes at once
+func (c *SplitClient) TreatmentsByFlagSetWithEvaluationOptions(key interface{}, flagSet string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]string {
+	treatmentsResult := map[string]string{}
+	sets := c.validateSets([]string{flagSet})
+	if sets == nil {
+		return treatmentsResult
+	}
+	result := c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsByFlagSetWithEvaluationOptions, telemetry.TreatmentsByFlagSetWithEvaluationOptions, &evaluationOptions)
+	for feature, treatmentResult := range result {
+		treatmentsResult[feature] = treatmentResult.Treatment
+	}
+	return treatmentsResult
+}
+
+// TreatmentsByFlagSetsWithEvaluationOptions evaluate multiple feature flag names belonging to flag sets for a single user and a set of attributes at once
+func (c *SplitClient) TreatmentsByFlagSetsWithEvaluationOptions(key interface{}, flagSets []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]string {
+	treatmentsResult := map[string]string{}
+	flagSets = c.validateSets(flagSets)
+	if flagSets == nil {
+		return treatmentsResult
+	}
+	result := c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsByFlagSetsWithEvaluationOptions, telemetry.TreatmentsByFlagSetsWithEvaluationOptions, &evaluationOptions)
 	for feature, treatmentResult := range result {
 		treatmentsResult[feature] = treatmentResult.Treatment
 	}
@@ -389,7 +466,12 @@ func (c *SplitClient) filterSetsAreInConfig(flagSets []string) []string {
 
 // TreatmentsWithConfig evaluates multiple feature flag names for a single user and set of attributes at once and returns configurations
 func (c *SplitClient) TreatmentsWithConfig(key interface{}, featureFlagNames []string, attributes map[string]interface{}) map[string]TreatmentResult {
-	return c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithConfig, telemetry.TreatmentsWithConfig)
+	return c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithConfig, telemetry.TreatmentsWithConfig, nil)
+}
+
+// TreatmentsWithConfigAndEvaluationOptions evaluates multiple feature flag names for a single user and set of attributes at once and returns configurations
+func (c *SplitClient) TreatmentsWithConfigAndEvaluationOptions(key interface{}, featureFlagNames []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]TreatmentResult {
+	return c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithConfigAndEvaluationOptions, telemetry.TreatmentsWithConfigByFlagSetAndEvaluationOptions, &evaluationOptions)
 }
 
 // TreatmentsWithConfigByFlagSet evaluates multiple feature flag names belonging to a flag set for a single user and set of attributes at once and returns configurations
@@ -399,7 +481,17 @@ func (c *SplitClient) TreatmentsWithConfigByFlagSet(key interface{}, flagSet str
 	if sets == nil {
 		return treatmentsResult
 	}
-	return c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsWithConfigByFlagSet, telemetry.TreatmentsWithConfigByFlagSet)
+	return c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsWithConfigByFlagSet, telemetry.TreatmentsWithConfigByFlagSet, nil)
+}
+
+// TreatmentsWithConfigByFlagSetAndEvaluationOptions evaluates multiple feature flag names belonging to a flag set for a single user and set of attributes at once and returns configurations
+func (c *SplitClient) TreatmentsWithConfigByFlagSetAndEvaluationOptions(key interface{}, flagSet string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]TreatmentResult {
+	treatmentsResult := make(map[string]TreatmentResult)
+	sets := c.validateSets([]string{flagSet})
+	if sets == nil {
+		return treatmentsResult
+	}
+	return c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsWithConfigByFlagSetAndEvaluationOptions, telemetry.TreatmentsWithConfigByFlagSetAndEvaluationOptions, &evaluationOptions)
 }
 
 // TreatmentsWithConfigByFlagSet evaluates multiple feature flag names belonging to a flag sets for a single user and set of attributes at once and returns configurations
@@ -409,7 +501,17 @@ func (c *SplitClient) TreatmentsWithConfigByFlagSets(key interface{}, flagSets [
 	if flagSets == nil {
 		return treatmentsResult
 	}
-	return c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsWithConfigByFlagSets, telemetry.TreatmentsWithConfigByFlagSets)
+	return c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsWithConfigByFlagSets, telemetry.TreatmentsWithConfigByFlagSets, nil)
+}
+
+// TreatmentsWithConfigByFlagSetsAndEvaluationOptions evaluates multiple feature flag names belonging to a flag sets for a single user and set of attributes at once and returns configurations
+func (c *SplitClient) TreatmentsWithConfigByFlagSetsAndEvaluationOptions(key interface{}, flagSets []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]TreatmentResult {
+	treatmentsResult := make(map[string]TreatmentResult)
+	flagSets = c.validateSets(flagSets)
+	if flagSets == nil {
+		return treatmentsResult
+	}
+	return c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsWithConfigByFlagSetsAndEvaluationOptions, telemetry.TreatmentsWithConfigByFlagSetsAndEvaluationOptions, &evaluationOptions)
 }
 
 // isDestroyed returns true if the client has been destroyed