Add support for sending flag decisions along with decision metadata. (#292)

* Sends decisions regardless of decision source.

Author: Mike Davis

pkg/client/client.go

@@ -76,8 +76,10 @@ func (o *OptimizelyClient) Activate(experimentKey string, userContext entities.U
 	if experimentDecision.Variation != nil && decisionContext.Experiment != nil {
 		// send an impression event
 		result = experimentDecision.Variation.Key
-		impressionEvent := event.CreateImpressionUserEvent(decisionContext.ProjectConfig, *decisionContext.Experiment, *experimentDecision.Variation, userContext)
-		o.EventProcessor.ProcessEvent(impressionEvent)
+		if ue, ok := event.CreateImpressionUserEvent(decisionContext.ProjectConfig, *decisionContext.Experiment,
+			experimentDecision.Variation, userContext, "", experimentKey, "experiment"); ok {
+			o.EventProcessor.ProcessEvent(ue)
+		}
 	}
 
 	return result, err
@@ -129,11 +131,11 @@ func (o *OptimizelyClient) IsFeatureEnabled(featureKey string, userContext entit
 		}
 	}
 
-	if featureDecision.Source == decision.FeatureTest && featureDecision.Variation != nil {
-		// send impression event for feature tests
-		impressionEvent := event.CreateImpressionUserEvent(decisionContext.ProjectConfig, featureDecision.Experiment, *featureDecision.Variation, userContext)
-		o.EventProcessor.ProcessEvent(impressionEvent)
+	if ue, ok := event.CreateImpressionUserEvent(decisionContext.ProjectConfig, featureDecision.Experiment,
+		featureDecision.Variation, userContext, featureKey, featureDecision.Experiment.Key, featureDecision.Source); ok {
+		o.EventProcessor.ProcessEvent(ue)
 	}
+
 	return result, err
 }
 
@@ -463,14 +465,19 @@ func (o *OptimizelyClient) GetDetailedFeatureDecisionUnsafe(featureKey string, u
 	if featureDecision.Variation != nil {
 		decisionInfo.Enabled = featureDecision.Variation.FeatureEnabled
 
+		// This information is only necessary for feature tests.
+		// For rollouts experiments and variations are an implementation detail only.
 		if featureDecision.Source == decision.FeatureTest {
 			decisionInfo.VariationKey = featureDecision.Variation.Key
 			decisionInfo.ExperimentKey = featureDecision.Experiment.Key
-			// Triggers impression events when applicable
-			if !disableTracking {
-				// send impression event for feature tests
-				impressionEvent := event.CreateImpressionUserEvent(decisionContext.ProjectConfig, featureDecision.Experiment, *featureDecision.Variation, userContext)
-				o.EventProcessor.ProcessEvent(impressionEvent)
+		}
+
+		// Triggers impression events when applicable
+		if !disableTracking {
+			// send impression event for feature tests
+			if ue, ok := event.CreateImpressionUserEvent(decisionContext.ProjectConfig, featureDecision.Experiment,
+				featureDecision.Variation, userContext, featureKey, featureDecision.Experiment.Key, featureDecision.Source); ok {
+				o.EventProcessor.ProcessEvent(ue)
 			}
 		}
 	}
@@ -624,12 +631,14 @@ func (o *OptimizelyClient) getFeatureDecision(featureKey, variableKey string, us
 		return decisionContext, featureDecision, e
 	}
 
+	decisionContext.ProjectConfig = projectConfig
 	feature, e := projectConfig.GetFeatureByKey(featureKey)
 	if e != nil {
 		o.logger.Warning(fmt.Sprintf(`Could not get feature for key "%s": %s`, featureKey, e))
 		return decisionContext, featureDecision, nil
 	}
 
+	decisionContext.Feature = &feature
 	variable := entities.Variable{}
 	if variableKey != "" {
 		variable, err = projectConfig.GetVariableByKey(feature.Key, variableKey)
@@ -639,12 +648,7 @@ func (o *OptimizelyClient) getFeatureDecision(featureKey, variableKey string, us
 		}
 	}
 
-	decisionContext = decision.FeatureDecisionContext{
-		Feature:       &feature,
-		ProjectConfig: projectConfig,
-		Variable:      variable,
-	}
-
+	decisionContext.Variable = variable
 	featureDecision, err = o.DecisionService.GetFeatureDecision(decisionContext, userContext)
 	if err != nil {
 		o.logger.Warning(fmt.Sprintf(`Received error while making a decision for feature "%s": %s`, featureKey, err))

pkg/client/client_test.go

@@ -2320,7 +2320,7 @@ func (s *ClientTestSuiteFM) TestIsFeatureEnabledWithDecisionError() {
 	s.mockDecisionService.AssertExpectations(s.T())
 }
 
-func (s *ClientTestSuiteFM) TestIsFeatureEnabledErrorCases() {
+func (s *ClientTestSuiteFM) TestIsFeatureEnabledErrorConfig() {
 	testUserContext := entities.UserContext{ID: "test_user_1"}
 	testFeatureKey := "test_feature_key"
 
@@ -2335,13 +2335,22 @@ func (s *ClientTestSuiteFM) TestIsFeatureEnabledErrorCases() {
 	result, _ := client.IsFeatureEnabled(testFeatureKey, testUserContext)
 	s.False(result)
 	s.mockDecisionService.AssertNotCalled(s.T(), "GetFeatureDecision")
+}
+
+func (s *ClientTestSuiteFM) TestIsFeatureEnabledErrorFeatureKey() {
+	testUserContext := entities.UserContext{ID: "test_user_1"}
+	testFeatureKey := "test_feature_key"
 
 	// Test invalid feature key
 	expectedError := errors.New("Invalid feature key")
 	s.mockConfig.On("GetFeatureByKey", testFeatureKey).Return(entities.Feature{}, expectedError)
+	s.mockConfig.On("GetBotFiltering").Return(true)
 	s.mockConfigManager.On("GetConfig").Return(s.mockConfig, nil)
 
-	client = OptimizelyClient{
+	s.mockEventProcessor.On("ProcessEvent", mock.Anything).Return(true)
+
+	client := OptimizelyClient{
+		EventProcessor:  s.mockEventProcessor,
 		ConfigManager:   s.mockConfigManager,
 		DecisionService: s.mockDecisionService,
 		logger:          logging.GetLogger("", ""),
@@ -2813,9 +2822,18 @@ func (s *ClientTestSuiteTrackNotification) TestRemoveOnTrackThrowsErrorWhenRemov
 	mockNotificationCenter.AssertExpectations(s.T())
 }
 
-func TestClientTestSuite(t *testing.T) {
+func TestClientTestSuiteAB(t *testing.T) {
 	suite.Run(t, new(ClientTestSuiteAB))
+}
+
+func TestClientTestSuiteFM(t *testing.T) {
 	suite.Run(t, new(ClientTestSuiteFM))
+}
+
+func TestClientTestSuiteTrackEvent(t *testing.T) {
 	suite.Run(t, new(ClientTestSuiteTrackEvent))
+}
+
+func TestClientTestSuiteTrackNotification(t *testing.T) {
 	suite.Run(t, new(ClientTestSuiteTrackNotification))
 }

pkg/client/fixtures_test.go

@@ -77,6 +77,9 @@ func (c *MockProjectConfig) GetAnonymizeIP() bool {
 func (c *MockProjectConfig) GetBotFiltering() bool {
 	return false
 }
+func (c *MockProjectConfig) SendFlagDecisions() bool {
+	return false
+}
 
 type MockProjectConfigManager struct {
 	projectConfig config.ProjectConfig

pkg/config/datafileprojectconfig/config.go

@@ -47,6 +47,7 @@ type DatafileProjectConfig struct {
 	rolloutMap           map[string]entities.Rollout
 	anonymizeIP          bool
 	botFiltering         bool
+	sendFlagDecisions    bool
 }
 
 // GetDatafile returns a string representation of the environment's datafile
@@ -178,6 +179,11 @@ func (c DatafileProjectConfig) GetGroupByID(groupID string) (entities.Group, err
 	return entities.Group{}, fmt.Errorf(`group with ID "%s" not found`, groupID)
 }
 
+// SendFlagDecisions determines whether impressions events are sent for ALL decision types
+func (c DatafileProjectConfig) SendFlagDecisions() bool {
+	return c.sendFlagDecisions
+}
+
 // NewDatafileProjectConfig initializes a new datafile from a json byte array using the default JSON datafile parser
 func NewDatafileProjectConfig(jsonDatafile []byte, logger logging.OptimizelyLogProducer) (*DatafileProjectConfig, error) {
 	datafile, err := Parse(jsonDatafile)
@@ -217,6 +223,7 @@ func NewDatafileProjectConfig(jsonDatafile []byte, logger logging.OptimizelyLogP
 		projectID:            datafile.ProjectID,
 		revision:             datafile.Revision,
 		rolloutMap:           rolloutMap,
+		sendFlagDecisions:    datafile.SendFlagDecisions,
 	}
 
 	logger.Info("Datafile is valid.")

pkg/config/datafileprojectconfig/entities/entities.go

@@ -106,19 +106,20 @@ type Rollout struct {
 
 // Datafile represents the datafile we get from Optimizely
 type Datafile struct {
-	Attributes     []Attribute   `json:"attributes"`
-	Audiences      []Audience    `json:"audiences"`
-	Experiments    []Experiment  `json:"experiments"`
-	Groups         []Group       `json:"groups"`
-	FeatureFlags   []FeatureFlag `json:"featureFlags"`
-	Events         []Event       `json:"events"`
-	Rollouts       []Rollout     `json:"rollouts"`
-	TypedAudiences []Audience    `json:"typedAudiences"`
-	Variables      []string      `json:"variables"`
-	AccountID      string        `json:"accountId"`
-	ProjectID      string        `json:"projectId"`
-	Revision       string        `json:"revision"`
-	Version        string        `json:"version"`
-	AnonymizeIP    bool          `json:"anonymizeIP"`
-	BotFiltering   bool          `json:"botFiltering"`
+	Attributes        []Attribute   `json:"attributes"`
+	Audiences         []Audience    `json:"audiences"`
+	Experiments       []Experiment  `json:"experiments"`
+	Groups            []Group       `json:"groups"`
+	FeatureFlags      []FeatureFlag `json:"featureFlags"`
+	Events            []Event       `json:"events"`
+	Rollouts          []Rollout     `json:"rollouts"`
+	TypedAudiences    []Audience    `json:"typedAudiences"`
+	Variables         []string      `json:"variables"`
+	AccountID         string        `json:"accountId"`
+	ProjectID         string        `json:"projectId"`
+	Revision          string        `json:"revision"`
+	Version           string        `json:"version"`
+	AnonymizeIP       bool          `json:"anonymizeIP"`
+	BotFiltering      bool          `json:"botFiltering"`
+	SendFlagDecisions bool          `json:"sendFlagDecisions"`
 }

pkg/config/interface.go

@@ -41,6 +41,7 @@ type ProjectConfig interface {
 	GetGroupByID(string) (entities.Group, error)
 	GetProjectID() string
 	GetRevision() string
+	SendFlagDecisions() bool
 }
 
 // ProjectConfigManager maintains an instance of the ProjectConfig

pkg/decision/entities.go

@@ -45,7 +45,7 @@ type UnsafeFeatureDecisionInfo struct {
 }
 
 // Source is where the decision came from
-type Source string
+type Source = string
 
 const (
 	// Rollout - the decision came from a rollout

pkg/event/events.go

@@ -40,12 +40,21 @@ type UserEvent struct {
 
 // ImpressionEvent represents an impression event
 type ImpressionEvent struct {
-	EntityID     string `json:"entity_id"`
-	Key          string `json:"key"`
 	Attributes   []VisitorAttribute
-	VariationID  string `json:"variation_id"`
-	CampaignID   string `json:"campaign_id"`
-	ExperimentID string `json:"experiment_id"`
+	CampaignID   string           `json:"campaign_id"`
+	EntityID     string           `json:"entity_id"`
+	ExperimentID string           `json:"experiment_id"`
+	Key          string           `json:"key"`
+	Metadata     DecisionMetadata `json:"metadata"`
+	VariationID  string           `json:"variation_id"`
+}
+
+// DecisionMetadata captures additional information regarding the decision
+type DecisionMetadata struct {
+	FlagKey      string `json:"flag_key"`
+	RuleKey      string `json:"rule_key"`
+	RuleType     string `json:"rule_type"`
+	VariationKey string `json:"variation_key"`
 }
 
 // ConversionEvent represents a conversion event
@@ -101,9 +110,10 @@ type Snapshot struct {
 
 // Decision represents a decision of a snapshot
 type Decision struct {
-	VariationID  string `json:"variation_id"`
-	CampaignID   string `json:"campaign_id"`
-	ExperimentID string `json:"experiment_id"`
+	VariationID  string           `json:"variation_id"`
+	CampaignID   string           `json:"campaign_id"`
+	ExperimentID string           `json:"experiment_id"`
+	Metadata     DecisionMetadata `json:"metadata"`
 }
 
 // SnapshotEvent represents an event of a snapshot

pkg/event/factory.go

@@ -23,7 +23,9 @@ import (
 	"time"
 
 	guuid "github.com/google/uuid"
+
 	"github.com/optimizely/go-sdk/pkg/config"
+	decisionPkg "github.com/optimizely/go-sdk/pkg/decision"
 	"github.com/optimizely/go-sdk/pkg/entities"
 	"github.com/optimizely/go-sdk/pkg/utils"
 )
@@ -57,26 +59,48 @@ func CreateEventContext(projectConfig config.ProjectConfig) Context {
 	return context
 }
 
-func createImpressionEvent(projectConfig config.ProjectConfig, experiment entities.Experiment,
-	variation entities.Variation, attributes map[string]interface{}) ImpressionEvent {
+func createImpressionEvent(
+	projectConfig config.ProjectConfig,
+	experiment entities.Experiment,
+	variation *entities.Variation,
+	attributes map[string]interface{},
+	flagKey, ruleKey, ruleType string,
+) ImpressionEvent {
+
+	metadata := DecisionMetadata{
+		FlagKey:  flagKey,
+		RuleKey:  ruleKey,
+		RuleType: ruleType,
+	}
+
+	var variationID string
+	if variation != nil {
+		metadata.VariationKey = variation.Key
+		variationID = variation.ID
+	}
 
-	impression := ImpressionEvent{}
-	impression.Key = impressionKey
-	impression.EntityID = experiment.LayerID
-	impression.Attributes = getEventAttributes(projectConfig, attributes)
-	impression.VariationID = variation.ID
-	impression.ExperimentID = experiment.ID
-	impression.CampaignID = experiment.LayerID
+	event := ImpressionEvent{
+		Attributes:   getEventAttributes(projectConfig, attributes),
+		CampaignID:   experiment.LayerID,
+		EntityID:     experiment.LayerID,
+		ExperimentID: experiment.ID,
+		Key:          impressionKey,
+		Metadata:     metadata,
+		VariationID:  variationID,
+	}
 
-	return impression
+	return event
 }
 
 // CreateImpressionUserEvent creates and returns ImpressionEvent for user
 func CreateImpressionUserEvent(projectConfig config.ProjectConfig, experiment entities.Experiment,
-	variation entities.Variation,
-	userContext entities.UserContext) UserEvent {
+	variation *entities.Variation, userContext entities.UserContext, flagKey, ruleKey, ruleType string) (UserEvent, bool) {
+
+	if (ruleType == decisionPkg.Rollout || variation == nil) && !projectConfig.SendFlagDecisions() {
+		return UserEvent{}, false
+	}
 
-	impression := createImpressionEvent(projectConfig, experiment, variation, userContext.Attributes)
+	impression := createImpressionEvent(projectConfig, experiment, variation, userContext.Attributes, flagKey, ruleKey, ruleType)
 
 	userEvent := UserEvent{}
 	userEvent.Timestamp = makeTimestamp()
@@ -85,7 +109,7 @@ func CreateImpressionUserEvent(projectConfig config.ProjectConfig, experiment en
 	userEvent.Impression = &impression
 	userEvent.EventContext = CreateEventContext(projectConfig)
 
-	return userEvent
+	return userEvent, true
 }
 
 // create an impression visitor
@@ -94,6 +118,7 @@ func createImpressionVisitor(userEvent UserEvent) Visitor {
 	decision.CampaignID = userEvent.Impression.CampaignID
 	decision.ExperimentID = userEvent.Impression.ExperimentID
 	decision.VariationID = userEvent.Impression.VariationID
+	decision.Metadata = userEvent.Impression.Metadata
 
 	dispatchEvent := SnapshotEvent{}
 	dispatchEvent.Timestamp = makeTimestamp()