feat(decision): Hook up the different pieces of rollouts. (#45)

Author: Michael Ng

README.md

@@ -1,5 +1,41 @@
 # Optimizely Go SDK
 
+## Usage
+
+### Instantiation
+To start using the SDK, create an instance using our factory method:
+
+```
+import "github.com/optimizely/go-sdk/optimizely/client"
+
+optimizelyFactory := &client.OptimizelyFactory{
+  SDKKey: "[SDK_KEY_HERE]",
+}
+
+client, err := optimizelyFactory.Client()
+
+// You can also instantiate with a hard-coded datafile
+optimizelyFactory := &client.OptimizelyFactory{
+	Datafile: []byte("datafile_string"),
+}
+
+client, err := optimizelyFactory.Client()
+
+```
+
+### Feature Rollouts
+```
+user := entities.UserContext{
+  ID: "optimizely end user",
+  Attributes: entities.UserAttributes{
+    "state":      "California",
+    "likes_donuts": true,
+  },
+}
+
+enabled, _ := client.IsFeatureEnabled("binary_feature", user)
+```
+
 ## Command line interface
 A CLI has been provided to illustrate the functionality of the SDK. Simply run `go-sdk` for help.
 ```$sh

examples/main.go

@@ -2,17 +2,19 @@ package main
 
 import (
 	"fmt"
-
 	"time"
 
 	"github.com/optimizely/go-sdk/optimizely/client"
 	"github.com/optimizely/go-sdk/optimizely/entities"
 	"github.com/optimizely/go-sdk/optimizely/event"
+	"github.com/optimizely/go-sdk/optimizely/logging"
 )
 
 func main() {
+	logging.SetLogLevel(logging.LogLevelDebug)
 	optimizelyFactory := &client.OptimizelyFactory{
-		SDKKey: "ABC",
+		SDKKey:   "4SLpaJA1r1pgE6T2CoMs9q",
+		Datafile: []byte("datafile_string"),
 	}
 	client, err := optimizelyFactory.Client()
 
@@ -29,7 +31,7 @@ func main() {
 		},
 	}
 
-	enabled, _ := client.IsFeatureEnabled("go_sdk", user)
+	enabled, _ := client.IsFeatureEnabled("binary_feature", user)
 	fmt.Printf("Is feature enabled? %v", enabled)
 
 	processor := event.NewEventProcessor(100, 100)

optimizely/client/client.go

@@ -18,6 +18,7 @@ package client
 
 import (
 	"errors"
+	"fmt"
 
 	"github.com/optimizely/go-sdk/optimizely"
 	"github.com/optimizely/go-sdk/optimizely/decision"
@@ -54,12 +55,22 @@ func (o *OptimizelyClient) IsFeatureEnabled(featureKey string, userContext entit
 		ProjectConfig: projectConfig,
 	}
 
+	userID := userContext.ID
+	logger.Debug(fmt.Sprintf(`Evaluating feature "%s" for user "%s".`, featureKey, userID))
 	featureDecision, err := o.decisionService.GetFeatureDecision(featureDecisionContext, userContext)
 	if err != nil {
 		logger.Error("Received an error while computing feature decision", err)
 		return false, err
 	}
 
+	logger.Debug(fmt.Sprintf(`Decision made for feature "%s" for user "%s" with the following reason: "%s". Source: "%s".`, featureKey, userID, featureDecision.Reason, featureDecision.Source))
+
+	if featureDecision.Variation.FeatureEnabled == true {
+		logger.Info(fmt.Sprintf(`Feature "%s" is enabled for user "%s".`, featureKey, userID))
+	} else {
+		logger.Info(fmt.Sprintf(`Feature "%s" is not enabled for user "%s".`, featureKey, userID))
+	}
+
 	// @TODO(mng): send impression event
 	return featureDecision.Variation.FeatureEnabled, nil
 }

optimizely/config/datafileProjectConfig/config.go

@@ -79,7 +79,7 @@ func NewDatafileProjectConfig(jsonDatafile []byte) (*DatafileProjectConfig, erro
 	experiments, experimentKeyMap := mappers.MapExperiments(datafile.Experiments)
 	rolloutMap := mappers.MapRollouts(datafile.Rollouts)
 	config := &DatafileProjectConfig{
-		audienceMap:          mappers.MapAudiences(datafile.Audiences),
+		audienceMap:          mappers.MapAudiences(datafile.TypedAudiences),
 		experimentMap:        experiments,
 		experimentKeyToIDMap: experimentKeyMap,
 		rolloutMap:           rolloutMap,

optimizely/config/datafileProjectConfig/entities/entities.go

@@ -20,7 +20,13 @@ package entities
 type Audience struct {
 	ID         string      `json:"id"`
 	Name       string      `json:"name"`
-	Conditions interface{} `json:"condition"`
+	Conditions interface{} `json:"conditions"`
+}
+
+// Attribute represents an Attribute object from the Optimizely datafile
+type Attribute struct {
+	ID  string `json:"id"`
+	Key string `json:"key"`
 }
 
 // Experiment represents an Experiment object from the Optimizely datafile
@@ -38,11 +44,19 @@ type Experiment struct {
 
 // FeatureFlag represents a FeatureFlag object from the Optimizely datafile
 type FeatureFlag struct {
-	ID            string   `json:"id"`
-	RolloutID     string   `json:"rolloutId"`
-	Key           string   `json:"key"`
-	ExperimentIDs []string `json:"experimentIds"`
-	Variables     []string `json:"variables"`
+	ID            string     `json:"id"`
+	RolloutID     string     `json:"rolloutId"`
+	Key           string     `json:"key"`
+	ExperimentIDs []string   `json:"experimentIds"`
+	Variables     []Variable `json:"variables"`
+}
+
+// Variable represents a Variable object from the Optimizely datafile
+type Variable struct {
+	DefaultValue string `json:"defaultValue"`
+	ID           string `json:"id"`
+	Key          string `json:"key"`
+	Type         string `json:"type"`
 }
 
 // trafficAllocation represents a traffic allocation range from the Optimizely datafile
@@ -76,6 +90,7 @@ type Rollout struct {
 type Datafile struct {
 	AccountID      string        `json:"accountId"`
 	AnonymizeIP    bool          `json:"anonymizeIP"`
+	Attributes     []Attribute   `json:"attributes"`
 	Audiences      []Audience    `json:"audiences"`
 	BotFiltering   bool          `json:"botFiltering"`
 	Experiments    []Experiment  `json:"experiments"`

optimizely/config/datafileProjectConfig/mappers/condition_trees.go

@@ -19,15 +19,15 @@ package mappers
 import (
 	"encoding/json"
 	"errors"
-	"github.com/optimizely/go-sdk/optimizely/entities"
 	"reflect"
+
+	"github.com/optimizely/go-sdk/optimizely/entities"
 )
 
 var ErrEmptyTree = errors.New("Empty Tree")
 
 // Takes the conditions array from the audience in the datafile and turns it into a condition tree
 func buildConditionTree(conditions interface{}) (conditionTree *entities.TreeNode, retErr error) {
-
 	value := reflect.ValueOf(conditions)
 	visited := make(map[interface{}]bool)
 

optimizely/decision/bucketer/experiment_bucketer.go

@@ -55,7 +55,7 @@ func (b MurmurhashBucketer) Bucket(bucketingID string, experiment entities.Exper
 		return variation, reasons.BucketedIntoVariation, nil
 	}
 
-	return entities.Variation{}, reasons.BucketedVariationNotFound, nil
+	return entities.Variation{ID: bucketedVariationID}, reasons.BucketedVariationNotFound, nil
 }
 
 func (b MurmurhashBucketer) bucketToEntity(bucketKey string, trafficAllocations []entities.Range) (entityID string) {

optimizely/decision/composite_feature_service.go

@@ -22,40 +22,44 @@ import (
 
 // CompositeFeatureService is the default out-of-the-box feature decision service
 type CompositeFeatureService struct {
-	experimentDecisionService        ExperimentDecisionService
-	rolloutExperimentDecisionService ExperimentDecisionService
+	experimentDecisionService ExperimentDecisionService
+	rolloutDecisionService    FeatureDecisionService
 }
 
 // NewCompositeFeatureService returns a new instance of the CompositeFeatureService
-func NewCompositeFeatureService(experimentDecisionService ExperimentDecisionService) *CompositeFeatureService {
-	if experimentDecisionService == nil {
-		experimentDecisionService = NewCompositeExperimentService()
-	}
+func NewCompositeFeatureService() *CompositeFeatureService {
 	return &CompositeFeatureService{
-		experimentDecisionService: experimentDecisionService,
+		rolloutDecisionService: NewRolloutService(),
 	}
 }
 
 // GetDecision returns a decision for the given feature and user context
-func (featureService CompositeFeatureService) GetDecision(decisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error) {
-	featureDecision := FeatureDecision{}
+func (f CompositeFeatureService) GetDecision(decisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error) {
 	feature := decisionContext.Feature
 
 	// Check if user is bucketed in feature experiment
-	// @TODO: add in a feature decision service that takes into account multiple experiments (via group mutex)
-	experiment := feature.FeatureExperiments[0]
-	experimentDecisionContext := ExperimentDecisionContext{
-		Experiment:    &experiment,
-		ProjectConfig: decisionContext.ProjectConfig,
-	}
+	if f.experimentDecisionService != nil {
+		// @TODO: add in a feature decision service that takes into account multiple experiments (via group mutex)
+		experiment := feature.FeatureExperiments[0]
+		experimentDecisionContext := ExperimentDecisionContext{
+			Experiment:    &experiment,
+			ProjectConfig: decisionContext.ProjectConfig,
+		}
 
-	experimentDecision, err := featureService.experimentDecisionService.GetDecision(experimentDecisionContext, userContext)
-	if err != nil {
-		// @TODO(mng): handle error here
+		experimentDecision, err := f.experimentDecisionService.GetDecision(experimentDecisionContext, userContext)
+		featureDecision := FeatureDecision{
+			Experiment: experiment,
+			Decision:   experimentDecision.Decision,
+			Variation:  experimentDecision.Variation,
+		}
+		return featureDecision, err
 	}
-	featureDecision.Experiment = experiment
-	featureDecision.Decision = experimentDecision.Decision
-	featureDecision.Variation = experimentDecision.Variation
 
-	return featureDecision, nil
+	featureDecisionContext := FeatureDecisionContext{
+		Feature:       feature,
+		ProjectConfig: decisionContext.ProjectConfig,
+	}
+	featureDecision, err := f.rolloutDecisionService.GetDecision(featureDecisionContext, userContext)
+	featureDecision.Source = Rollout
+	return featureDecision, err
 }

optimizely/decision/composite_service.go

@@ -28,20 +28,18 @@ type CompositeService struct {
 
 // NewCompositeService returns a new instance of the DefeaultDecisionEngine
 func NewCompositeService() *CompositeService {
-	experimentDecisionService := NewCompositeExperimentService()
-	featureDecisionService := NewCompositeFeatureService(experimentDecisionService)
+	featureDecisionService := NewCompositeFeatureService()
 	return &CompositeService{
-		experimentDecisionServices: []ExperimentDecisionService{experimentDecisionService},
-		featureDecisionServices:    []FeatureDecisionService{featureDecisionService},
+		featureDecisionServices: []FeatureDecisionService{featureDecisionService},
 	}
 }
 
 // GetFeatureDecision returns a decision for the given feature key
-func (service CompositeService) GetFeatureDecision(featureDecisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error) {
+func (s CompositeService) GetFeatureDecision(featureDecisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error) {
 	var featureDecision FeatureDecision
 
 	// loop through the different features decision services until we get a decision
-	for _, decisionService := range service.featureDecisionServices {
+	for _, decisionService := range s.featureDecisionServices {
 		featureDecision, err := decisionService.GetDecision(featureDecisionContext, userContext)
 		if err != nil {
 			// @TODO: log error

optimizely/decision/entities.go

@@ -34,6 +34,14 @@ type FeatureDecisionContext struct {
 	ProjectConfig optimizely.ProjectConfig
 }
 
+// Source is where the decision came from
+type Source string
+
+const (
+	// Rollout - the decision came from a rollout
+	Rollout Source = "Rollout"
+)
+
 // Decision contains base information about a decision
 type Decision struct {
 	DecisionMade bool
@@ -43,6 +51,7 @@ type Decision struct {
 // FeatureDecision contains the decision information about a feature
 type FeatureDecision struct {
 	Decision
+	Source     Source
 	Experiment entities.Experiment
 	Variation  entities.Variation
 }