decision

Documentation

Index

• type CompositeExperimentService
  • func NewCompositeExperimentService() *CompositeExperimentService
  • func (s CompositeExperimentService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error)
• type CompositeFeatureService
  • func NewCompositeFeatureService() *CompositeFeatureService
  • func (f CompositeFeatureService) GetDecision(decisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error)
• type CompositeService
  • func NewCompositeService(notificationCenter notification.Center) *CompositeService
  • func (s CompositeService) GetFeatureDecision(featureDecisionContext FeatureDecisionContext, ...) (FeatureDecision, error)
  • func (s CompositeService) OnDecision(callback func(notification.DecisionNotification))
• type Decision
• type DecisionService
• type ExperimentBucketerService
  • func NewExperimentBucketerService() *ExperimentBucketerService
  • func (s ExperimentBucketerService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error)
• type ExperimentDecision
• type ExperimentDecisionContext
• type ExperimentDecisionService
• type ExperimentTargetingService
  • func NewExperimentTargetingService() *ExperimentTargetingService
  • func (s ExperimentTargetingService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error)
• type FeatureDecision
• type FeatureDecisionContext
• type FeatureDecisionService
• type RolloutService
  • func NewRolloutService() *RolloutService
  • func (r RolloutService) GetDecision(decisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error)
• type Source

Types

type CompositeExperimentService

type CompositeExperimentService struct {
	// contains filtered or unexported fields
}

CompositeExperimentService bridges together the various experiment decision services that ship by default with the SDK

func NewCompositeExperimentService

func NewCompositeExperimentService() *CompositeExperimentService

NewCompositeExperimentService creates a new instance of the CompositeExperimentService

func (CompositeExperimentService) GetDecision

func (s CompositeExperimentService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error)

GetDecision returns a decision for the given experiment and user context

type CompositeFeatureService

type CompositeFeatureService struct {
	// contains filtered or unexported fields
}

CompositeFeatureService is the default out-of-the-box feature decision service

func NewCompositeFeatureService

func NewCompositeFeatureService() *CompositeFeatureService

NewCompositeFeatureService returns a new instance of the CompositeFeatureService

func (CompositeFeatureService) GetDecision

func (f CompositeFeatureService) GetDecision(decisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error)

GetDecision returns a decision for the given feature and user context

type CompositeService

type CompositeService struct {
	// contains filtered or unexported fields
}

CompositeService is the entrypoint into the decision service. It provides out of the box decision making for Features and Experiments.

func NewCompositeService

func NewCompositeService(notificationCenter notification.Center) *CompositeService

NewCompositeService returns a new instance of the DefeaultDecisionEngine

func (CompositeService) GetFeatureDecision

func (s CompositeService) GetFeatureDecision(featureDecisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error)

GetFeatureDecision returns a decision for the given feature key

func (CompositeService) OnDecision

func (s CompositeService) OnDecision(callback func(notification.DecisionNotification))

OnDecision registers a handler for Decision notifications

type Decision

type Decision struct {
	DecisionMade bool
	Reason       reasons.Reason
}

Decision contains base information about a decision

type DecisionService

type DecisionService interface {
	GetFeatureDecision(FeatureDecisionContext, entities.UserContext) (FeatureDecision, error)
	OnDecision(func(notification.DecisionNotification))
}

DecisionService interface is used to make a decision for a given feature or experiment

type ExperimentBucketerService

type ExperimentBucketerService struct {
	// contains filtered or unexported fields
}

ExperimentBucketerService makes a decision using the experiment bucketer

func NewExperimentBucketerService

func NewExperimentBucketerService() *ExperimentBucketerService

NewExperimentBucketerService returns a new instance of the ExperimentBucketerService

func (ExperimentBucketerService) GetDecision

func (s ExperimentBucketerService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error)

GetDecision returns the decision with the variation the user is bucketed into

type ExperimentDecision

type ExperimentDecision struct {
	Decision
	Variation entities.Variation
}

ExperimentDecision contains the decision information about an experiment

type ExperimentDecisionContext

type ExperimentDecisionContext struct {
	Experiment    *entities.Experiment
	ProjectConfig optimizely.ProjectConfig
}

ExperimentDecisionContext contains the information needed to be able to make a decision for a given experiment

type ExperimentDecisionService

type ExperimentDecisionService interface {
	GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error)
}

ExperimentDecisionService can make a decision about an experiment

type ExperimentTargetingService

type ExperimentTargetingService struct {
	// contains filtered or unexported fields
}

ExperimentTargetingService makes a decision using audience targeting

func NewExperimentTargetingService

func NewExperimentTargetingService() *ExperimentTargetingService

NewExperimentTargetingService returns a new instance of ExperimentTargetingService

func (ExperimentTargetingService) GetDecision

func (s ExperimentTargetingService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error)

GetDecision applies audience targeting from the given experiment to the given user. The only decision it makes is whether to exclude the user from the experiment.

type FeatureDecision

type FeatureDecision struct {
	Decision
	Source     Source
	Experiment entities.Experiment
	Variation  entities.Variation
}

FeatureDecision contains the decision information about a feature

type FeatureDecisionContext

type FeatureDecisionContext struct {
	Feature       *entities.Feature
	ProjectConfig optimizely.ProjectConfig
}

FeatureDecisionContext contains the information needed to be able to make a decision for a given feature

type FeatureDecisionService

type FeatureDecisionService interface {
	GetDecision(decisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error)
}

FeatureDecisionService can make a decision about a Feature Flag (can be feature test or rollout)

type RolloutService

type RolloutService struct {
	// contains filtered or unexported fields
}

RolloutService makes a feature decision for a given feature rollout

func NewRolloutService

func NewRolloutService() *RolloutService

NewRolloutService returns a new instance of the Rollout service

func (RolloutService) GetDecision

func (r RolloutService) GetDecision(decisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error)

GetDecision returns a decision for the given feature and user context

type Source

type Source string

Source is where the decision came from

const (
	// Rollout - the decision came from a rollout
	Rollout Source = "rollout"
	// FeatureTest - the decision came from a feature test
	FeatureTest Source = "feature-test"
)