feat(notifications): Add notifications for decisions. (#50)

Author: Michael Ng

optimizely/client/client_test.go

@@ -48,6 +48,7 @@ func (p *MockProjectConfigManager) GetConfig() optimizely.ProjectConfig {
 }
 
 type MockDecisionService struct {
+	decision.DecisionService
 	mock.Mock
 }
 

optimizely/client/factory.go

@@ -21,6 +21,8 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/optimizely/go-sdk/optimizely/notification"
+
 	"github.com/optimizely/go-sdk/optimizely"
 	"github.com/optimizely/go-sdk/optimizely/config"
 	"github.com/optimizely/go-sdk/optimizely/decision"
@@ -88,6 +90,8 @@ func (f OptimizelyFactory) ClientWithOptions(clientOptions Options) (*Optimizely
 		client.cancelFunc = cancel
 	}
 
+	notificationCenter := notification.NewNotificationCenter()
+
 	if clientOptions.ProjectConfigManager != nil {
 		client.configManager = clientOptions.ProjectConfigManager
 	} else if f.SDKKey != "" {
@@ -102,7 +106,7 @@ func (f OptimizelyFactory) ClientWithOptions(clientOptions Options) (*Optimizely
 	}
 
 	// @TODO: allow decision service to be passed in via options
-	client.decisionService = decision.NewCompositeService()
+	client.decisionService = decision.NewCompositeService(notificationCenter)
 	client.isValid = true
 	return client, nil
 }

optimizely/decision/composite_service.go

@@ -17,39 +17,74 @@
 package decision
 
 import (
+	"fmt"
+
 	"github.com/optimizely/go-sdk/optimizely/entities"
+	"github.com/optimizely/go-sdk/optimizely/logging"
+	"github.com/optimizely/go-sdk/optimizely/notification"
 )
 
+var csLogger = logging.GetLogger("CompositeDecisionService")
+
 // CompositeService is the entrypoint into the decision service. It provides out of the box decision making for Features and Experiments.
 type CompositeService struct {
 	experimentDecisionServices []ExperimentDecisionService
 	featureDecisionServices    []FeatureDecisionService
+	notificationCenter         notification.Center
 }
 
 // NewCompositeService returns a new instance of the DefeaultDecisionEngine
-func NewCompositeService() *CompositeService {
+func NewCompositeService(notificationCenter notification.Center) *CompositeService {
 	featureDecisionService := NewCompositeFeatureService()
 	return &CompositeService{
 		featureDecisionServices: []FeatureDecisionService{featureDecisionService},
+		notificationCenter:      notificationCenter,
 	}
 }
 
 // GetFeatureDecision returns a decision for the given feature key
 func (s CompositeService) GetFeatureDecision(featureDecisionContext FeatureDecisionContext, userContext entities.UserContext) (FeatureDecision, error) {
 	var featureDecision FeatureDecision
-
+	var err error
 	// loop through the different features decision services until we get a decision
 	for _, decisionService := range s.featureDecisionServices {
-		featureDecision, err := decisionService.GetDecision(featureDecisionContext, userContext)
+		featureDecision, err = decisionService.GetDecision(featureDecisionContext, userContext)
 		if err != nil {
 			// @TODO: log error
 		}
 
 		if featureDecision.DecisionMade {
-			return featureDecision, err
+			break
 		}
 	}
 
 	// @TODO: add errors
-	return featureDecision, nil
+	if s.notificationCenter != nil {
+		decisionInfo := map[string]interface{}{
+			"feature": map[string]interface{}{
+				"feature_key":     featureDecisionContext.Feature.Key,
+				"feature_enabled": featureDecision.Variation.FeatureEnabled,
+				"source":          featureDecision.Source,
+			},
+		}
+		decisionNotification := notification.DecisionNotification{
+			DecisionInfo: decisionInfo,
+			Type:         notification.Feature,
+			UserContext:  userContext,
+		}
+		s.notificationCenter.Send(notification.Decision, decisionNotification)
+	}
+	return featureDecision, err
+}
+
+// OnDecision registers a handler for Decision notifications
+func (s CompositeService) OnDecision(callback func(notification.DecisionNotification)) {
+	handler := func(payload interface{}) {
+		if decisionNotification, ok := payload.(notification.DecisionNotification); ok {
+			callback(decisionNotification)
+		} else {
+			csLogger.Warning(fmt.Sprintf("Unable to convert notification payload %v into DecisionNotification", payload))
+		}
+	}
+	s.notificationCenter.AddHandler(notification.Decision, handler)
 }

optimizely/decision/interface.go

@@ -18,11 +18,13 @@ package decision
 
 import (
 	"github.com/optimizely/go-sdk/optimizely/entities"
+	"github.com/optimizely/go-sdk/optimizely/notification"
 )
 
 // DecisionService interface is used to make a decision for a given feature or experiment
 type DecisionService interface {
 	GetFeatureDecision(FeatureDecisionContext, entities.UserContext) (FeatureDecision, error)
+	OnDecision(func(notification.DecisionNotification))
 }
 
 // ExperimentDecisionService can make a decision about an experiment

optimizely/notification/center.go

@@ -0,0 +1,59 @@
+/****************************************************************************
+ * Copyright 2019, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package notification
+
+import "fmt"
+
+// Center handles all notification listeners. It keeps track of the Manager for each type of notification.
+type Center interface {
+	AddHandler(Type, func(interface{})) (int, error)
+	Send(Type, interface{}) error
+}
+
+// DefaultCenter contains all the notification managers
+type DefaultCenter struct {
+	managerMap map[Type]Manager
+}
+
+// NewNotificationCenter returns a new notification center
+func NewNotificationCenter() *DefaultCenter {
+	decisionNotificationManager := NewAtomicManager()
+	managerMap := make(map[Type]Manager)
+	managerMap[Decision] = decisionNotificationManager
+	return &DefaultCenter{
+		managerMap: managerMap,
+	}
+}
+
+// AddHandler adds a handler for the given notification type
+func (c *DefaultCenter) AddHandler(notificationType Type, handler func(interface{})) (int, error) {
+	if manager, ok := c.managerMap[notificationType]; ok {
+		return manager.AddHandler(handler)
+	}
+
+	return -1, fmt.Errorf("No notification manager found for type %s", notificationType)
+}
+
+// Send sends the given notification payload to all listeners of type
+func (c *DefaultCenter) Send(notificationType Type, notification interface{}) error {
+	if manager, ok := c.managerMap[notificationType]; ok {
+		manager.Send(notification)
+		return nil
+	}
+
+	return fmt.Errorf("No notification manager found for type %s", notificationType)
+}

optimizely/notification/center_test.go

@@ -0,0 +1,41 @@
+package notification
+
+import (
+	"testing"
+
+	"github.com/optimizely/go-sdk/optimizely/entities"
+	"github.com/stretchr/testify/mock"
+)
+
+type MockReceiver struct {
+	mock.Mock
+}
+
+func (m *MockReceiver) handleNotification(notification interface{}) {
+	m.Called(notification)
+}
+
+func TestNotificationCenter(t *testing.T) {
+	mockReceiver := new(MockReceiver)
+	mockReceiver2 := new(MockReceiver)
+
+	testUser := entities.UserContext{}
+	testDecisionNotification := DecisionNotification{
+		Type:        Feature,
+		UserContext: testUser,
+		DecisionInfo: map[string]interface{}{
+			"feature": map[string]interface{}{
+				"source": "Rollout",
+			},
+		},
+	}
+	mockReceiver.On("handleNotification", testDecisionNotification)
+	mockReceiver2.On("handleNotification", testDecisionNotification)
+	notificationCenter := NewNotificationCenter()
+	notificationCenter.AddHandler(Decision, mockReceiver.handleNotification)
+	notificationCenter.AddHandler(Decision, mockReceiver2.handleNotification)
+	notificationCenter.Send(Decision, testDecisionNotification)
+
+	mockReceiver.AssertExpectations(t)
+	mockReceiver2.AssertExpectations(t)
+}

optimizely/notification/entities.go

@@ -0,0 +1,42 @@
+/****************************************************************************
+ * Copyright 2019, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package notification
+
+import "github.com/optimizely/go-sdk/optimizely/entities"
+
+// Type is the type of notification
+type Type string
+
+const (
+	// Decision notification type
+	Decision Type = "decision"
+)
+
+// DecisionNotificationType is the type of decision notification
+type DecisionNotificationType string
+
+const (
+	// Feature is used when the decision is returned as part of evaluating a feature
+	Feature DecisionNotificationType = "feature"
+)
+
+// DecisionNotification is a notification triggered when a decision is made for either a feature or an experiment
+type DecisionNotification struct {
+	Type         DecisionNotificationType
+	UserContext  entities.UserContext
+	DecisionInfo map[string]interface{}
+}

optimizely/notification/handler.go

@@ -0,0 +1,22 @@
+/****************************************************************************
+ * Copyright 2019, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package notification
+
+// Handler is a generic interface for Optimizely notification listeners
+type Handler interface {
+	handle(interface{})
+}

optimizely/notification/manager.go

@@ -0,0 +1,54 @@
+/****************************************************************************
+ * Copyright 2019, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package notification
+
+import (
+	"sync/atomic"
+)
+
+// Manager is a generic interface for managing notifications of a particular type
+type Manager interface {
+	AddHandler(func(interface{})) (int, error)
+	Send(message interface{})
+}
+
+// AtomicManager adds handlers atomically
+type AtomicManager struct {
+	handlers map[uint32]func(interface{})
+	counter  uint32
+}
+
+// NewAtomicManager creates a new instance of the atomic manager
+func NewAtomicManager() *AtomicManager {
+	return &AtomicManager{
+		handlers: make(map[uint32]func(interface{})),
+	}
+}
+
+// AddHandler adds the given handler
+func (am *AtomicManager) AddHandler(newHandler func(interface{})) (int, error) {
+	atomic.AddUint32(&am.counter, 1)
+	am.handlers[am.counter] = newHandler
+	return int(am.counter), nil
+}
+
+// Send sends the notification to the registered handlers
+func (am *AtomicManager) Send(notification interface{}) {
+	for _, handler := range am.handlers {
+		handler(notification)
+	}
+}

optimizely/notification/manager_test.go

@@ -0,0 +1,40 @@
+package notification
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type managerMockReceiver struct {
+	mock.Mock
+}
+
+func (m *managerMockReceiver) handle(notification interface{}) {
+	m.Called(notification)
+}
+
+func (m *managerMockReceiver) handleBetter(notification interface{}) {
+	m.Called(notification)
+}
+
+func TestAtomicManager(t *testing.T) {
+	payload := map[string]interface{}{
+		"key": "test",
+	}
+
+	mockReceiver := new(managerMockReceiver)
+	mockReceiver.On("handle", payload)
+	mockReceiver.On("handleBetter", payload)
+
+	atomicManager := NewAtomicManager()
+	result, _ := atomicManager.AddHandler(mockReceiver.handle)
+	assert.Equal(t, 1, result)
+
+	result, _ = atomicManager.AddHandler(mockReceiver.handleBetter)
+	assert.Equal(t, 2, result)
+
+	atomicManager.Send(payload)
+	mockReceiver.AssertExpectations(t)
+}