feat(log): Adds default logger implementation. (#30)

Author: Michael Ng

optimizely/client/client.go

@@ -20,16 +20,25 @@ import (
 	"github.com/optimizely/go-sdk/optimizely/config"
 	"github.com/optimizely/go-sdk/optimizely/decision"
 	"github.com/optimizely/go-sdk/optimizely/entities"
+	"github.com/optimizely/go-sdk/optimizely/logging"
 )
 
+var logger = logging.GetLogger("Client")
+
 // OptimizelyClient is the entry point to the Optimizely SDK
 type OptimizelyClient struct {
-	decisionService decision.DecisionService
 	configManager   config.ProjectConfigManager
+	decisionService decision.DecisionService
+	isValid         bool
 }
 
 // IsFeatureEnabled returns true if the feature is enabled for the given user
 func (optly *OptimizelyClient) IsFeatureEnabled(featureKey string, userID string, attributes map[string]interface{}) bool {
+	if !optly.isValid {
+		logger.Error("Optimizely instance is not valid. Failing IsFeatureEnabled.", nil)
+		return false
+	}
+
 	userContext := entities.UserContext{ID: userID, Attributes: entities.UserAttributes{Attributes: attributes}}
 
 	// @TODO(mng): we should fetch the Feature entity from the config service instead of manually creating it here

optimizely/client/factory.go

@@ -29,13 +29,13 @@ type OptimizelyFactory struct {
 }
 
 // Client returns a client initialized with the defaults
-func (factory OptimizelyFactory) Client() OptimizelyClient {
+func (f OptimizelyFactory) Client() OptimizelyClient {
 	var projectConfig config.ProjectConfig
 	var configManager config.ProjectConfigManager
-	if factory.Datafile != nil {
-		projectConfig = datafileProjectConfig.NewDatafileProjectConfig(factory.Datafile)
+	if f.Datafile != nil {
+		projectConfig = datafileProjectConfig.NewDatafileProjectConfig(f.Datafile)
 
-		if factory.SDKKey == "" {
+		if f.SDKKey == "" {
 			staticConfigManager := config.NewStaticProjectConfigManager(projectConfig)
 			configManager = staticConfigManager
 		}
@@ -45,6 +45,7 @@ func (factory OptimizelyFactory) Client() OptimizelyClient {
 	client := OptimizelyClient{
 		decisionService: decisionService,
 		configManager:   configManager,
+		isValid:         true,
 	}
 	return client
 }

optimizely/config/datafileProjectConfig/config.go

@@ -22,8 +22,11 @@ import (
 
 	"github.com/optimizely/go-sdk/optimizely/config/datafileProjectConfig/mappers"
 	"github.com/optimizely/go-sdk/optimizely/entities"
+	"github.com/optimizely/go-sdk/optimizely/logging"
 )
 
+var logger = logging.GetLogger("DatafileProjectConfig")
+
 // DatafileProjectConfig is a project config backed by a datafile
 type DatafileProjectConfig struct {
 	audienceMap          map[string]entities.Audience
@@ -36,7 +39,7 @@ type DatafileProjectConfig struct {
 func NewDatafileProjectConfig(jsonDatafile []byte) *DatafileProjectConfig {
 	datafile, err := Parse(jsonDatafile)
 	if err != nil {
-		// @TODO(mng): handle error
+		logger.Error("Error parsing datafile.", err)
 	}
 
 	experiments, experimentKeyMap := mappers.MapExperiments(datafile.Experiments)
@@ -46,6 +49,7 @@ func NewDatafileProjectConfig(jsonDatafile []byte) *DatafileProjectConfig {
 		experimentKeyToIDMap: experimentKeyMap,
 	}
 
+	logger.Info("Datafile is valid.")
 	return config
 }
 

optimizely/logging/interface.go

@@ -0,0 +1,15 @@
+package logging
+
+// OptimizelyLogConsumer consumes log messages produced by the log producers
+type OptimizelyLogConsumer interface {
+	Log(level int, message string)
+	SetLogLevel(logLevel int)
+}
+
+// OptimizelyLogProducer produces log messages to be consumed by the log consumer
+type OptimizelyLogProducer interface {
+	Debug(message string)
+	Info(message string)
+	Warning(message string)
+	Error(message string, err interface{})
+}

optimizely/logging/level_log_consumer.go

@@ -0,0 +1,32 @@
+package logging
+
+import (
+	"log"
+	"os"
+)
+
+// FilteredLevelLogConsumer is an implementation of the OptimizelyLogConsumer that filters by log level
+type FilteredLevelLogConsumer struct {
+	level  int
+	logger *log.Logger
+}
+
+// Log logs the message if it's log level is higher than or equal to the logger's set level
+func (l *FilteredLevelLogConsumer) Log(level int, message string) {
+	if l.level <= level {
+		l.logger.Println(message)
+	}
+}
+
+// SetLogLevel changes the log level to the given level
+func (l *FilteredLevelLogConsumer) SetLogLevel(level int) {
+	l.level = level
+}
+
+// NewStdoutFilteredLevelLogConsumer returns a new logger that logs to stdout
+func NewStdoutFilteredLevelLogConsumer(level int) *FilteredLevelLogConsumer {
+	return &FilteredLevelLogConsumer{
+		level:  level,
+		logger: log.New(os.Stdout, "[Optimizely]", log.LstdFlags),
+	}
+}

optimizely/logging/logger.go

@@ -0,0 +1,76 @@
+package logging
+
+import "fmt"
+
+var defaultLogConsumer OptimizelyLogConsumer
+
+const (
+	_ = iota
+
+	// LogLevelDebug log level
+	LogLevelDebug
+
+	// LogLevelInfo log level
+	LogLevelInfo
+
+	// LogLevelWarning log level
+	LogLevelWarning
+
+	// LogLevelError log level
+	LogLevelError
+)
+
+func init() {
+	defaultLogConsumer = NewStdoutFilteredLevelLogConsumer(LogLevelInfo)
+}
+
+// SetLogger replaces the default logger with the given logger
+func SetLogger(logger OptimizelyLogConsumer) {
+	defaultLogConsumer = logger
+}
+
+// SetLogLevel sets the log level to the given level
+func SetLogLevel(logLevel int) {
+	defaultLogConsumer.SetLogLevel(logLevel)
+}
+
+// GetLogger returns a log producer with the given name
+func GetLogger(name string) OptimizelyLogProducer {
+	return NamedLogProducer{
+		name: name,
+	}
+}
+
+// NamedLogProducer produces logs prefixed with its name
+type NamedLogProducer struct {
+	name string
+}
+
+// Debug logs the given message with a DEBUG level
+func (p NamedLogProducer) Debug(message string) {
+	p.log(LogLevelDebug, message)
+}
+
+// Info logs the given message with a INFO level
+func (p NamedLogProducer) Info(message string) {
+	p.log(LogLevelInfo, message)
+}
+
+// Warning logs the given message with a WARNING level
+func (p NamedLogProducer) Warning(message string) {
+	p.log(LogLevelWarning, message)
+}
+
+// Error logs the given message with a ERROR level
+func (p NamedLogProducer) Error(message string, err interface{}) {
+	if err != nil {
+		message = fmt.Sprintf("%s %v", message, err)
+	}
+	p.log(LogLevelError, message)
+}
+
+func (p NamedLogProducer) log(logLevel int, message string) {
+	// prepends the name to the message
+	message = fmt.Sprintf("[%s] %s", p.name, message)
+	defaultLogConsumer.Log(logLevel, message)
+}

optimizely/logging/logger_test.go

@@ -0,0 +1,52 @@
+package logging
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/stretchr/testify/mock"
+)
+
+type MockOptimizelyLogger struct {
+	mock.Mock
+	loggedMessages []string
+}
+
+func (m *MockOptimizelyLogger) Log(level int, message string) {
+	m.Called(level, message)
+	m.loggedMessages = append(m.loggedMessages, message)
+}
+
+func (m *MockOptimizelyLogger) SetLogLevel(level int) {
+	m.Called(level)
+}
+
+func TestNamedLoggerInfo(t *testing.T) {
+	testLogMessage := "Test info message"
+	expectedLogMessage := "[test-info] Test info message"
+	testLogger := new(MockOptimizelyLogger)
+	testLogger.On("Log", LogLevelInfo, expectedLogMessage)
+
+	SetLogger(testLogger)
+
+	logProducer := GetLogger("test-info")
+	logProducer.Info(testLogMessage)
+	testLogger.AssertExpectations(t)
+	assert.Equal(t, []string{expectedLogMessage}, testLogger.loggedMessages)
+}
+
+func TestNamedLoggerError(t *testing.T) {
+	testLogMessage := "Test error message"
+	expectedLogMessage := "[test-error] Test error message I am an error object"
+	testLogger := new(MockOptimizelyLogger)
+	testLogger.On("Log", LogLevelError, expectedLogMessage)
+	SetLogger(testLogger)
+
+	err := errors.New("I am an error object")
+	logProducer := GetLogger("test-error")
+	logProducer.Error(testLogMessage, err)
+	testLogger.AssertExpectations(t)
+	assert.Equal(t, []string{expectedLogMessage}, testLogger.loggedMessages)
+}