Remove panics; replace with error (FF-2512) (#54)

* Remove panics; replace with error (FF-2512)

* Remove IsAuthorized

* use new constructor newConfigurationStore in test

* 5.0.0

* rename promotedAttributeValue

Author: leoromanovsky

README.md

@@ -43,27 +43,29 @@ import (
     "github.com/Eppo-exp/golang-sdk/v4/eppoclient"
 )
 
-var eppoClient = &eppoclient.EppoClient{}
+var eppoClient *eppoclient.EppoClient
 
 func main() {
     assignmentLogger := NewExampleAssignmentLogger()
 
-    eppoClient = eppoclient.InitClient(eppoclient.Config{
+    eppoClient, err = eppoclient.InitClient(eppoclient.Config{
         SdkKey:           "<your_sdk_key>",
         AssignmentLogger: assignmentLogger,
     })
+    if err != nil {
+        log.Fatalf("Failed to initialize Eppo client: %v", err)
+    }
 }
 ```
 
-
 #### Assign anywhere
 
 ```go
 import (
     "github.com/Eppo-exp/golang-sdk/v4/eppoclient"
 )
 
-var eppoClient = &eppoclient.EppoClient{}
+var eppoClient *eppoclient.EppoClient
 
 variation := eppoClient.GetStringAssignment(
    "new-user-onboarding",
@@ -131,6 +133,38 @@ func main() {
 }
 ```
 
+### De-duplication of assignments
+
+The SDK may see many duplicate assignments in a short period of time, and if you
+have configured a logging function, they will be transmitted to your downstream
+event store. This increases the cost of storage as well as warehouse costs during experiment analysis.
+
+To mitigate this, an in-memory assignment cache is optionally available with expiration based on the least recently accessed time.
+
+It can be configured with a maximum size to fit your desired memory allocation.
+
+```go
+import (
+  "github.com/Eppo-exp/golang-sdk/v4/eppoclient"
+)
+
+var eppoClient *eppoclient.EppoClient
+
+func main() {
+  assignmentLogger := NewExampleAssignmentLogger()
+
+  eppoClient = eppoclient.InitClient(eppoclient.Config{
+    ApiKey:           "<your_sdk_key>",
+    // 10000 is the maximum number of assignments to cache
+    // Depending on the length of your flag and subject keys, taking a median
+    // length of 32 characters, each assignment cache entry uses approximately 112 bytes.
+    // Use this calculation to determine the maximum number of assignments to cache
+    // for the memory you wish to allocate.
+    AssignmentLogger: eppoclient.NewLruAssignmentLogger(assignmentLogger, 10000),
+  })
+}
+```
+
 ## Philosophy
 
 Eppo's SDKs are built for simplicity, speed and reliability. Flag configurations are compressed and distributed over a global CDN (Fastly), typically reaching your servers in under 15ms. Server SDKs continue polling Eppo’s API at 10-second intervals. Configurations are then cached locally, ensuring that each assignment is made instantly. Evaluation logic within each SDK consists of a few lines of simple numeric and string comparisons. The typed functions listed above are all developers need to understand, abstracting away the complexity of the Eppo's underlying (and expanding) feature set.

eppoclient/client.go

@@ -174,15 +174,11 @@ func (ec *EppoClient) GetBanditAction(flagKey string, subjectKey string, subject
 
 func (ec *EppoClient) getAssignment(config configuration, flagKey string, subjectKey string, subjectAttributes Attributes, variationType variationType) (interface{}, error) {
 	if subjectKey == "" {
-		panic("no subject key provided")
+		return nil, fmt.Errorf("no subject key provided")
 	}
 
 	if flagKey == "" {
-		panic("no flag key provided")
-	}
-
-	if ec.configRequestor != nil && !ec.configRequestor.IsAuthorized() {
-		panic("Unauthorized: please check your SDK key")
+		return nil, fmt.Errorf("no flag key provided")
 	}
 
 	flag, err := config.getFlagConfiguration(flagKey)

eppoclient/client_test.go

@@ -1,7 +1,6 @@
 package eppoclient
 
 import (
-	"log"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -10,26 +9,18 @@ import (
 
 func Test_AssignBlankExperiment(t *testing.T) {
 	var mockLogger = new(mockLogger)
-	client := newEppoClient(&configurationStore{}, nil, nil, mockLogger)
+	client := newEppoClient(newConfigurationStore(configuration{}), nil, nil, mockLogger)
 
-	assert.Panics(t, func() {
-		_, err := client.GetStringAssignment("", "subject-1", Attributes{}, "")
-		if err != nil {
-			log.Println(err)
-		}
-	})
+	_, err := client.GetStringAssignment("", "subject-1", Attributes{}, "")
+	assert.Error(t, err)
 }
 
 func Test_AssignBlankSubject(t *testing.T) {
 	var mockLogger = new(mockLogger)
-	client := newEppoClient(&configurationStore{}, nil, nil, mockLogger)
+	client := newEppoClient(newConfigurationStore(configuration{}), nil, nil, mockLogger)
 
-	assert.Panics(t, func() {
-		_, err := client.GetStringAssignment("experiment-1", "", Attributes{}, "")
-		if err != nil {
-			log.Println(err)
-		}
-	})
+	_, err := client.GetStringAssignment("experiment-1", "", Attributes{}, "")
+	assert.Error(t, err)
 }
 func Test_LogAssignment(t *testing.T) {
 	var mockLogger = new(mockLogger)

eppoclient/config.go

@@ -1,6 +1,9 @@
 package eppoclient
 
-import "time"
+import (
+	"fmt"
+	"time"
+)
 
 const default_base_url = "https://fscdn.eppo.cloud/api"
 
@@ -11,9 +14,9 @@ type Config struct {
 	PollerInterval   time.Duration
 }
 
-func (cfg *Config) validate() {
+func (cfg *Config) validate() error {
 	if cfg.SdkKey == "" {
-		panic("sdk key not set")
+		return fmt.Errorf("SDK key not set")
 	}
 
 	if cfg.BaseUrl == "" {
@@ -23,4 +26,6 @@ func (cfg *Config) validate() {
 	if cfg.PollerInterval <= 0 {
 		cfg.PollerInterval = 10 * time.Second
 	}
+
+	return nil
 }

eppoclient/config_test.go

@@ -12,7 +12,7 @@ func Test_config_defaultPollerInterval(t *testing.T) {
 		SdkKey: "blah",
 	}
 
-	cfg.validate()
-
+	err := cfg.validate()
+	assert.NoError(t, err)
 	assert.Equal(t, 10*time.Second, cfg.PollerInterval)
 }

eppoclient/configurationrequestor.go

@@ -20,10 +20,6 @@ func newConfigurationRequestor(httpClient httpClient, configStore *configuration
 	}
 }
 
-func (cr *configurationRequestor) IsAuthorized() bool {
-	return !cr.httpClient.isUnauthorized
-}
-
 func (cr *configurationRequestor) FetchAndStoreConfigurations() {
 	configuration, err := cr.fetchConfiguration()
 	if err != nil {

eppoclient/doc.go

@@ -36,7 +36,8 @@ func Test_e2e(t *testing.T) {
 
 	mockLogger := new(mockLogger)
 	mockLogger.Mock.On("LogAssignment", mock.Anything).Return()
-	client := InitClient(Config{BaseUrl: serverUrl, SdkKey: "dummy", AssignmentLogger: mockLogger})
+	client, err := InitClient(Config{BaseUrl: serverUrl, SdkKey: "dummy", AssignmentLogger: mockLogger})
+	assert.NoError(t, err)
 
 	// give client the time to "fetch" the mock config
 	time.Sleep(2 * time.Second)

eppoclient/eppoclient_e2e_test.go

@@ -4,12 +4,15 @@ package eppoclient
 
 import "net/http"
 
-var __version__ = "4.1.0"
+var __version__ = "5.0.0"
 
 // InitClient is required to start polling of experiments configurations and create
 // an instance of EppoClient, which could be used to get assignments information.
-func InitClient(config Config) *EppoClient {
-	config.validate()
+func InitClient(config Config) (*EppoClient, error) {
+	err := config.validate()
+	if err != nil {
+		return nil, err
+	}
 	sdkParams := SDKParams{sdkKey: config.SdkKey, sdkName: "go", sdkVersion: __version__}
 
 	httpClient := newHttpClient(config.BaseUrl, &http.Client{Timeout: REQUEST_TIMEOUT_SECONDS}, sdkParams)
@@ -23,5 +26,5 @@ func InitClient(config Config) *EppoClient {
 
 	client.poller.Start()
 
-	return client
+	return client, nil
 }

eppoclient/initclient.go

@@ -1,7 +1,9 @@
 package eppoclient
 
 import (
-	"github.com/hashicorp/golang-lru/v2"
+	"fmt"
+
+	lru "github.com/hashicorp/golang-lru/v2"
 )
 
 type LruAssignmentLogger struct {
@@ -22,20 +24,20 @@ type cacheValue struct {
 	variation  string
 }
 
-func NewLruAssignmentLogger(logger IAssignmentLogger, cacheSize int) IAssignmentLogger {
+func NewLruAssignmentLogger(logger IAssignmentLogger, cacheSize int) (IAssignmentLogger, error) {
 	cache, err := lru.New2Q[cacheKey, cacheValue](cacheSize)
 	if err != nil {
 		// err is only returned if `cacheSize` is invalid
 		// (e.g., <0) which should normally never happen.
-		panic(err)
+		return nil, fmt.Errorf("failed to create LRU cache: %w", err)
 	}
 	return &LruAssignmentLogger{
 		cache: cache,
 		inner: logger,
-	}
+	}, nil
 }
 
-func (self *LruAssignmentLogger) LogAssignment(event AssignmentEvent) {
+func (lal *LruAssignmentLogger) LogAssignment(event AssignmentEvent) {
 	key := cacheKey{
 		flag:    event.FeatureFlag,
 		subject: event.Subject,
@@ -44,11 +46,11 @@ func (self *LruAssignmentLogger) LogAssignment(event AssignmentEvent) {
 		allocation: event.Allocation,
 		variation:  event.Variation,
 	}
-	previousValue, recentlyLogged := self.cache.Get(key)
+	previousValue, recentlyLogged := lal.cache.Get(key)
 	if !recentlyLogged || previousValue != value {
-		self.inner.LogAssignment(event)
+		lal.inner.LogAssignment(event)
 		// Adding to cache after `LogAssignment` returned in
 		// case it panics.
-		self.cache.Add(key, value)
+		lal.cache.Add(key, value)
 	}
 }