[FSSDK-11587] Implement CMAB config

README.md

@@ -124,7 +124,10 @@ Below is a comprehensive list of available configuration properties.
 | log.level                                         | OPTIMIZELY_LOG_LEVEL                            | The log [level](https://github.com/rs/zerolog#leveled-logging) for the agent. Default: info                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | log.pretty                                        | OPTIMIZELY_LOG_PRETTY                           | Flag used to set colorized console output as opposed to structured json logs. Default: false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | name                                              | OPTIMIZELY_NAME                                 | Agent name. Default: optimizely                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| sdkKeys                                           | OPTIMIZELY_SDKKEYS                              | Comma delimited list of SDK keys used to initialize on startup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| sdkKeys                                           | OPTIMIZELY_SDKKEYS                              | Comma delimited list of SDK keys used to initialize on startup                                                                         | 
+| cmab               | OPTIMIZELY_CMAB           | Complete JSON configuration for CMAB. Format: see example below                                     |
+| cmab.cache         | OPTIMIZELY_CMAB_CACHE     | JSON configuration for just the CMAB cache section. Format: see example below                       |
+| cmab.retryConfig   | OPTIMIZELY_CMAB_RETRYCONFIG | JSON configuration for just the CMAB retry settings. Format: see example below                    |                                                                                                                                                                        
 | server.allowedHosts                               | OPTIMIZELY_SERVER_ALLOWEDHOSTS                  | List of allowed request host values. Requests whose host value does not match either the configured server.host, or one of these, will be rejected with a 404 response. To match all subdomains, you can use a leading dot (for example `.example.com` matches `my.example.com`, `hello.world.example.com`, etc.). You can use the value `.` to disable allowed host checking, allowing requests with any host. Request host is determined in the following priority order: 1. X-Forwarded-Host header value, 2. Forwarded header host= directive value, 3. Host property of request (see Host under https://pkg.go.dev/net/http#Request). Note: don't include port in these hosts values - port is stripped from the request host before comparing against these. |
 | server.batchRequests.maxConcurrency               | OPTIMIZELY_SERVER_BATCHREQUESTS_MAXCONCURRENCY  | Number of requests running in parallel. Default: 10                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | server.batchRequests.operationsLimit              | OPTIMIZELY_SERVER_BATCHREQUESTS_OPERATIONSLIMIT | Number of allowed operations. ( will flag an error if the number of operations exeeds this parameter) Default: 500                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -142,6 +145,25 @@ Below is a comprehensive list of available configuration properties.
 | webhook.projects.<_projectId_>.secret             | N/A                                             | Webhook secret used to validate webhook requests originating from the respective projectId                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | webhook.projects.<_projectId_>.skipSignatureCheck | N/A                                             | Boolean to indicate whether the signature should be validated. TODO remove in favor of empty secret.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 
+### CMAB Configuration Example
+
+```json
+{
+  "requestTimeout": "5s",
+  "cache": {
+    "type": "memory",
+    "size": 2000,
+    "ttl": "45m"
+  },
+  "retryConfig": {
+    "maxRetries": 3,
+    "initialBackoff": "100ms",
+    "maxBackoff": "10s",
+    "backoffMultiplier": 2.0
+  }
+}
+```
+
 More information about configuring Agent can be found in the [Advanced Configuration Notes](https://docs.developers.optimizely.com/experimentation/v4.0.0-full-stack/docs/advanced-configuration).
 
 ### API

cmd/optimizely/main.go

@@ -25,6 +25,7 @@ import (
 	"runtime"
 	"strings"
 	"syscall"
+	"time"
 
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
@@ -98,15 +99,94 @@ func loadConfig(v *viper.Viper) *config.AgentConfig {
 	}
 
 	// Check if JSON string was set using OPTIMIZELY_CLIENT_USERPROFILESERVICE environment variable
-	if userProfileService := v.GetStringMap("client.userprofileservice"); userProfileService != nil {
+	if userProfileService := v.GetStringMap("client.userprofileservice"); len(userProfileService) > 0 {
 		conf.Client.UserProfileService = userProfileService
 	}
 
 	// Check if JSON string was set using OPTIMIZELY_CLIENT_ODP_SEGMENTSCACHE environment variable
-	if odpSegmentsCache := v.GetStringMap("client.odp.segmentsCache"); odpSegmentsCache != nil {
+	if odpSegmentsCache := v.GetStringMap("client.odp.segmentsCache"); len(odpSegmentsCache) > 0 {
 		conf.Client.ODP.SegmentsCache = odpSegmentsCache
 	}
 
+	// Handle CMAB configuration using the same approach as UserProfileService
+	// Check for complete CMAB configuration first
+	if cmab := v.GetStringMap("cmab"); len(cmab) > 0 {
+		if timeout, ok := cmab["requestTimeout"].(string); ok {
+			if duration, err := time.ParseDuration(timeout); err == nil {
+				conf.CMAB.RequestTimeout = duration
+			}
+		}
+		if cache, ok := cmab["cache"].(map[string]interface{}); ok {
+			if cacheType, ok := cache["type"].(string); ok {
+				conf.CMAB.Cache.Type = cacheType
+			}
+			if cacheSize, ok := cache["size"].(float64); ok {
+				conf.CMAB.Cache.Size = int(cacheSize)
+			}
+			if cacheTTL, ok := cache["ttl"].(string); ok {
+				if duration, err := time.ParseDuration(cacheTTL); err == nil {
+					conf.CMAB.Cache.TTL = duration
+				}
+			}
+		}
+		if retryConfig, ok := cmab["retryConfig"].(map[string]interface{}); ok {
+			if maxRetries, ok := retryConfig["maxRetries"].(float64); ok {
+				conf.CMAB.RetryConfig.MaxRetries = int(maxRetries)
+			}
+			if initialBackoff, ok := retryConfig["initialBackoff"].(string); ok {
+				if duration, err := time.ParseDuration(initialBackoff); err == nil {
+					conf.CMAB.RetryConfig.InitialBackoff = duration
+				}
+			}
+			if maxBackoff, ok := retryConfig["maxBackoff"].(string); ok {
+				if duration, err := time.ParseDuration(maxBackoff); err == nil {
+					conf.CMAB.RetryConfig.MaxBackoff = duration
+				}
+			}
+			if backoffMultiplier, ok := retryConfig["backoffMultiplier"].(float64); ok {
+				conf.CMAB.RetryConfig.BackoffMultiplier = backoffMultiplier
+			}
+		}
+	}
+
+	// Check for individual map sections
+	if cmabCache := v.GetStringMap("cmab.cache"); len(cmabCache) > 0 {
+		if cacheType, ok := cmabCache["type"].(string); ok {
+			conf.CMAB.Cache.Type = cacheType
+		}
+		if cacheSize, ok := cmabCache["size"].(int); ok {
+			conf.CMAB.Cache.Size = cacheSize
+		} else if cacheSize, ok := cmabCache["size"].(float64); ok {
+			conf.CMAB.Cache.Size = int(cacheSize)
+		}
+		if cacheTTL, ok := cmabCache["ttl"].(string); ok {
+			if duration, err := time.ParseDuration(cacheTTL); err == nil {
+				conf.CMAB.Cache.TTL = duration
+			}
+		}
+	}
+
+	if cmabRetryConfig := v.GetStringMap("cmab.retryConfig"); len(cmabRetryConfig) > 0 {
+		if maxRetries, ok := cmabRetryConfig["maxRetries"].(int); ok {
+			conf.CMAB.RetryConfig.MaxRetries = maxRetries
+		} else if maxRetries, ok := cmabRetryConfig["maxRetries"].(float64); ok {
+			conf.CMAB.RetryConfig.MaxRetries = int(maxRetries)
+		}
+		if initialBackoff, ok := cmabRetryConfig["initialBackoff"].(string); ok {
+			if duration, err := time.ParseDuration(initialBackoff); err == nil {
+				conf.CMAB.RetryConfig.InitialBackoff = duration
+			}
+		}
+		if maxBackoff, ok := cmabRetryConfig["maxBackoff"].(string); ok {
+			if duration, err := time.ParseDuration(maxBackoff); err == nil {
+				conf.CMAB.RetryConfig.MaxBackoff = duration
+			}
+		}
+		if backoffMultiplier, ok := cmabRetryConfig["backoffMultiplier"].(float64); ok {
+			conf.CMAB.RetryConfig.BackoffMultiplier = backoffMultiplier
+		}
+	}
+
 	return conf
 }
 

cmd/optimizely/main_test.go

@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright 2019-2020,2022-2023, Optimizely, Inc. and contributors         *
+ * Copyright 2019-2020,2022-2025, 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.         *
@@ -17,7 +17,9 @@
 package main
 
 import (
+	"fmt"
 	"os"
+	"strings"
 	"testing"
 	"time"
 
@@ -178,6 +180,93 @@ func assertWebhook(t *testing.T, actual config.WebhookConfig) {
 	assert.False(t, actual.Projects[20000].SkipSignatureCheck)
 }
 
+func assertCMAB(t *testing.T, cmab config.CMABConfig) {
+	fmt.Println("In assertCMAB, received CMAB config:")
+	fmt.Printf("  RequestTimeout: %v\n", cmab.RequestTimeout)
+	fmt.Printf("  Cache: %#v\n", cmab.Cache)
+	fmt.Printf("  RetryConfig: %#v\n", cmab.RetryConfig)
+
+	// Base assertions
+	assert.Equal(t, 15*time.Second, cmab.RequestTimeout)
+
+	// Check cache configuration
+	cache := cmab.Cache
+	assert.Equal(t, "redis", cache.Type)
+	assert.Equal(t, 2000, cache.Size)
+	assert.Equal(t, 45*time.Minute, cache.TTL)
+
+	// Check retry configuration
+	retry := cmab.RetryConfig
+	assert.Equal(t, 5, retry.MaxRetries)
+	assert.Equal(t, 200*time.Millisecond, retry.InitialBackoff)
+	assert.Equal(t, 30*time.Second, retry.MaxBackoff)
+	assert.Equal(t, 3.0, retry.BackoffMultiplier)
+}
+
+func TestCMABEnvDebug(t *testing.T) {
+	_ = os.Setenv("OPTIMIZELY_CMAB", `{
+		"requestTimeout": "15s",
+		"cache": {
+			"type": "redis",
+			"size": 2000,
+			"ttl": "45m"
+		},
+		"retryConfig": {
+			"maxRetries": 5,
+			"initialBackoff": "200ms",
+			"maxBackoff": "30s",
+			"backoffMultiplier": 3.0
+		}
+	}`)
+
+	// Load config using Viper
+	v := viper.New()
+	v.SetEnvPrefix("optimizely")
+	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+	v.AutomaticEnv()
+
+	// Create config
+	assert.NoError(t, initConfig(v))
+	conf := loadConfig(v)
+
+	// Debug: Print the parsed config
+	fmt.Println("Parsed CMAB config from JSON env var:")
+	fmt.Printf("  RequestTimeout: %v\n", conf.CMAB.RequestTimeout)
+	fmt.Printf("  Cache: %+v\n", conf.CMAB.Cache)
+	fmt.Printf("  RetryConfig: %+v\n", conf.CMAB.RetryConfig)
+
+	// Call assertCMAB
+	assertCMAB(t, conf.CMAB)
+}
+
+func TestCMABPartialConfig(t *testing.T) {
+	// Clean any existing environment variables
+	os.Unsetenv("OPTIMIZELY_CMAB")
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE")
+	os.Unsetenv("OPTIMIZELY_CMAB_RETRYCONFIG")
+
+	// Set partial configuration through CMAB_CACHE and CMAB_RETRYCONFIG
+	_ = os.Setenv("OPTIMIZELY_CMAB_CACHE", `{"type": "redis", "size": 3000}`)
+	_ = os.Setenv("OPTIMIZELY_CMAB_RETRYCONFIG", `{"maxRetries": 10}`)
+
+	// Load config
+	v := viper.New()
+	assert.NoError(t, initConfig(v))
+	conf := loadConfig(v)
+
+	// Cache assertions
+	assert.Equal(t, "redis", conf.CMAB.Cache.Type)
+	assert.Equal(t, 3000, conf.CMAB.Cache.Size)
+
+	// RetryConfig assertions
+	assert.Equal(t, 10, conf.CMAB.RetryConfig.MaxRetries)
+
+	// Clean up
+	os.Unsetenv("OPTIMIZELY_CMAB")
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE")
+	os.Unsetenv("OPTIMIZELY_CMAB_RETRYCONFIG")
+}
+
 func TestViperYaml(t *testing.T) {
 	v := viper.New()
 	v.Set("config.filename", "./testdata/default.yaml")
@@ -392,6 +481,21 @@ func TestViperEnv(t *testing.T) {
 	_ = os.Setenv("OPTIMIZELY_WEBHOOK_PROJECTS_20000_SDKKEYS", "xxx,yyy,zzz")
 	_ = os.Setenv("OPTIMIZELY_WEBHOOK_PROJECTS_20000_SKIPSIGNATURECHECK", "false")
 
+	_ = os.Setenv("OPTIMIZELY_CMAB", `{
+		"requestTimeout": "15s",
+		"cache": {
+			"type": "redis",
+			"size": 2000,
+			"ttl": "45m"
+		},
+		"retryConfig": {
+			"maxRetries": 5,
+			"initialBackoff": "200ms",
+			"maxBackoff": "30s",
+			"backoffMultiplier": 3.0
+		}
+	}`)
+
 	_ = os.Setenv("OPTIMIZELY_RUNTIME_BLOCKPROFILERATE", "1")
 	_ = os.Setenv("OPTIMIZELY_RUNTIME_MUTEXPROFILEFRACTION", "2")
 
@@ -407,6 +511,7 @@ func TestViperEnv(t *testing.T) {
 	assertAPI(t, actual.API)
 	//assertWebhook(t, actual.Webhook) // Maps don't appear to be supported
 	assertRuntime(t, actual.Runtime)
+	assertCMAB(t, actual.CMAB)
 }
 
 func TestLoggingWithIncludeSdkKey(t *testing.T) {
@@ -507,3 +612,31 @@ func Test_initTracing(t *testing.T) {
 		})
 	}
 }
+
+func TestCMABComplexJSON(t *testing.T) {
+	// Clean any existing environment variables for CMAB
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE_TYPE")
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE_SIZE")
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE_TTL")
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE_REDIS_HOST")
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE_REDIS_PASSWORD")
+	os.Unsetenv("OPTIMIZELY_CMAB_CACHE_REDIS_DATABASE")
+
+	// Set complex JSON environment variable for CMAB cache
+	_ = os.Setenv("OPTIMIZELY_CMAB_CACHE", `{"type":"redis","size":5000,"ttl":"3h"}`)
+
+	defer func() {
+		// Clean up
+		os.Unsetenv("OPTIMIZELY_CMAB_CACHE")
+	}()
+
+	v := viper.New()
+	assert.NoError(t, initConfig(v))
+	actual := loadConfig(v)
+
+	// Test cache settings from JSON environment variable
+	cache := actual.CMAB.Cache
+	assert.Equal(t, "redis", cache.Type)
+	assert.Equal(t, 5000, cache.Size)
+	assert.Equal(t, 3*time.Hour, cache.TTL)
+}

config.yaml

@@ -262,3 +262,28 @@ synchronization:
     datafile:
         enable: false
         default: "redis"
+
+##
+## cmab: Contextual Multi-Armed Bandit configuration
+##
+cmab:
+    ## timeout for CMAB API requests
+    requestTimeout: 10s
+    ## CMAB cache configuration
+    cache:
+        ## cache type (memory or redis)
+        type: "memory"
+        ## maximum number of entries for in-memory cache
+        size: 1000
+        ## time-to-live for cached decisions
+        ttl: 30m
+    ## retry configuration for CMAB API requests
+    retryConfig:
+        ## maximum number of retry attempts
+        maxRetries: 3
+        ## initial backoff duration
+        initialBackoff: 100ms
+        ## maximum backoff duration
+        maxBackoff: 10s
+        ## multiplier for exponential backoff
+        backoffMultiplier: 2.0