[FSSDK-11177] public api exposed for cmab cache

Author: junaed-optimizely

OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj

@@ -199,6 +199,9 @@
     <Compile Include="..\OptimizelySDK\Cmab\CmabRetryConfig.cs">
       <Link>Cmab\CmabRetryConfig.cs</Link>
     </Compile>
+    <Compile Include="..\OptimizelySDK\Cmab\CmabConfig.cs">
+      <Link>Cmab\CmabConfig.cs</Link>
+    </Compile>
     <Compile Include="..\OptimizelySDK\Cmab\CmabModels.cs">
       <Link>Cmab\CmabModels.cs</Link>
     </Compile>

OptimizelySDK.Tests/CmabTests/DefaultCmabServiceTest.cs

@@ -390,7 +390,7 @@ public void TestDecideWithCmabExperimentIncludeReasons()
 
             Assert.IsNotNull(decision);
             Assert.IsNotNull(decision.Reasons);
-            var expectedMessage = string.Format(CmabConstants.CmabDecisionFetched, TEST_USER_ID,
+            var expectedMessage = string.Format(CmabConstants.CMAB_DECISION_FETCHED, TEST_USER_ID,
                 TEST_EXPERIMENT_KEY);
             Assert.IsTrue(decision.Reasons.Any(r => r.Contains(expectedMessage)),
                 "Decision reasons should include CMAB fetch success message.");
@@ -415,7 +415,7 @@ public void TestDecideWithCmabErrorReturnsErrorDecision()
             Assert.IsNull(decision.VariationKey);
             Assert.IsNull(decision.CmabUuid);
             Assert.IsTrue(decision.Reasons.Any(r => r.Contains(
-                string.Format(CmabConstants.CmabFetchFailed, TEST_EXPERIMENT_KEY))));
+                string.Format(CmabConstants.CMAB_FETCH_FAILED, TEST_EXPERIMENT_KEY))));
             Assert.AreEqual(1, _cmabService.CallCount);
         }
 

OptimizelySDK.Tests/CmabTests/OptimizelyUserContextCmabTest.cs

@@ -16,13 +16,18 @@
  */
 
 using System;
+using System.Reflection;
 using Moq;
 using NUnit.Framework;
+using OptimizelySDK.Bucketing;
+using OptimizelySDK.Cmab;
 using OptimizelySDK.Config;
 using OptimizelySDK.Event;
 using OptimizelySDK.Event.Dispatcher;
+using OptimizelySDK.ErrorHandler;
 using OptimizelySDK.Logger;
 using OptimizelySDK.Notifications;
+using OptimizelySDK.Odp;
 using OptimizelySDK.Tests.ConfigTest;
 using OptimizelySDK.Tests.EventTest;
 using OptimizelySDK.Tests.Utils;
@@ -39,6 +44,13 @@ public void Initialize()
         {
             LoggerMock = new Mock<ILogger>();
             LoggerMock.Setup(i => i.Log(It.IsAny<LogLevel>(), It.IsAny<string>()));
+            ResetCmabConfiguration();
+        }
+
+        [TearDown]
+        public void Cleanup()
+        {
+            ResetCmabConfiguration();
         }
 
         [Test]
@@ -244,5 +256,76 @@ public void TestGetFeatureVariableJSONEmptyDatafileTest()
                 "userId"));
             optimizely.Dispose();
         }
+
+        [Test]
+        public void SetCmabCacheConfigStoresCacheSizeAndTtl()
+        {
+            const int cacheSize = 1234;
+            var cacheTtl = TimeSpan.FromSeconds(45);
+
+            OptimizelyFactory.SetCmabCacheConfig(cacheSize, cacheTtl);
+
+            var config = GetCurrentCmabConfiguration();
+
+            Assert.IsNotNull(config);
+            Assert.AreEqual(cacheSize, config.CacheSize);
+            Assert.AreEqual(cacheTtl, config.CacheTtl);
+            Assert.IsNull(config.CustomCache);
+        }
+
+        [Test]
+        public void SetCmabCustomCacheStoresCustomCacheInstance()
+        {
+            var customCache = new LruCache<CmabCacheEntry>(maxSize: 10, itemTimeout: TimeSpan.FromMinutes(2));
+
+            OptimizelyFactory.SetCmabCustomCache(customCache);
+
+            var config = GetCurrentCmabConfiguration();
+
+            Assert.IsNotNull(config);
+            Assert.AreSame(customCache, config.CustomCache);
+            Assert.IsNull(config.CacheSize);
+            Assert.IsNull(config.CacheTtl);
+        }
+
+        [Test]
+        public void NewDefaultInstanceUsesConfiguredCmabCache()
+        {
+            const int cacheSize = 7;
+            var cacheTtl = TimeSpan.FromSeconds(30);
+            OptimizelyFactory.SetCmabCacheConfig(cacheSize, cacheTtl);
+
+            var logger = new NoOpLogger();
+            var errorHandler = new NoOpErrorHandler();
+            var projectConfig = DatafileProjectConfig.Create(TestData.Datafile, logger, errorHandler);
+            var configManager = new FallbackProjectConfigManager(projectConfig);
+
+            var optimizely = OptimizelyFactory.NewDefaultInstance(configManager, logger: logger, errorHandler: errorHandler);
+
+            var decisionService = Reflection.GetFieldValue<DecisionService, Optimizely>(optimizely, "DecisionService");
+            Assert.IsNotNull(decisionService);
+
+            var cmabService = Reflection.GetFieldValue<ICmabService, DecisionService>(decisionService, "CmabService");
+            Assert.IsInstanceOf<DefaultCmabService>(cmabService);
+
+            var cache = Reflection.GetFieldValue<LruCache<CmabCacheEntry>, DefaultCmabService>((DefaultCmabService)cmabService, "_cmabCache");
+            Assert.IsNotNull(cache);
+            Assert.AreEqual(cacheSize, cache.MaxSizeForTesting);
+            Assert.AreEqual(cacheTtl, cache.TimeoutForTesting);
+
+            optimizely.Dispose();
+        }
+
+        private static void ResetCmabConfiguration()
+        {
+            var field = typeof(OptimizelyFactory).GetField("CmabConfiguration", BindingFlags.NonPublic | BindingFlags.Static);
+            field?.SetValue(null, null);
+        }
+
+        private static CmabConfig GetCurrentCmabConfiguration()
+        {
+            var field = typeof(OptimizelyFactory).GetField("CmabConfiguration", BindingFlags.NonPublic | BindingFlags.Static);
+            return field?.GetValue(null) as CmabConfig;
+        }
     }
 }

OptimizelySDK.Tests/OptimizelyFactoryTest.cs

@@ -312,7 +312,7 @@ OptimizelyDecideOption[] options
             // Check if CMAB is properly configured
             if (experiment.Cmab == null)
             {
-                var message = string.Format(CmabConstants.CmabExperimentNotProperlyConfigured,
+                var message = string.Format(CmabConstants.CMAB_EXPERIMENT_NOT_PROPERLY_CONFIGURED,
                     experiment.Key);
                 Logger.Log(LogLevel.ERROR, reasons.AddInfo(message));
                 return Result<VariationDecisionResult>.NewResult(
@@ -337,7 +337,7 @@ OptimizelyDecideOption[] options
             var entityId = bucketResult.ResultObject;
             if (string.IsNullOrEmpty(entityId))
             {
-                var message = string.Format(CmabConstants.UserNotInCmabExperiment, userId,
+                var message = string.Format(CmabConstants.USER_NOT_IN_CMAB_EXPERIMENT, userId,
                     experiment.Key);
                 Logger.Log(LogLevel.INFO, reasons.AddInfo(message));
                 return Result<VariationDecisionResult>.NewResult(
@@ -359,7 +359,7 @@ OptimizelyDecideOption[] options
 
                 if (cmabDecision == null || string.IsNullOrEmpty(cmabDecision.VariationId))
                 {
-                    var message = string.Format(CmabConstants.CmabFetchFailed, experiment.Key);
+                    var message = string.Format(CmabConstants.CMAB_FETCH_FAILED, experiment.Key);
                     Logger.Log(LogLevel.ERROR, reasons.AddInfo(message));
                     return Result<VariationDecisionResult>.NewResult(
                         new VariationDecisionResult(null, null, true), reasons);
@@ -378,7 +378,7 @@ OptimizelyDecideOption[] options
                         new VariationDecisionResult(null), reasons);
                 }
 
-                var successMessage = string.Format(CmabConstants.CmabDecisionFetched, userId,
+                var successMessage = string.Format(CmabConstants.CMAB_DECISION_FETCHED, userId,
                     experiment.Key);
                 Logger.Log(LogLevel.INFO, reasons.AddInfo(successMessage));
 
@@ -387,7 +387,7 @@ OptimizelyDecideOption[] options
             }
             catch (Exception ex)
             {
-                var message = string.Format(CmabConstants.CmabFetchFailed, experiment.Key);
+                var message = string.Format(CmabConstants.CMAB_FETCH_FAILED, experiment.Key);
                 Logger.Log(LogLevel.ERROR, reasons.AddInfo($"{message} Error: {ex.Message}"));
                 return Result<VariationDecisionResult>.NewResult(
                     new VariationDecisionResult(null, null, true), reasons);

OptimizelySDK/Bucketing/DecisionService.cs

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025, Optimizely
+ *
+ * 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.
+ */
+
+using System;
+using OptimizelySDK.Odp;
+
+namespace OptimizelySDK.Cmab
+{
+    /// <summary>
+    ///     Configuration options for CMAB (Contextual Multi-Armed Bandit) functionality.
+    /// </summary>
+    public class CmabConfig
+    {
+        /// <summary>
+        ///     Initializes a new instance of the CmabConfig class with default cache settings.
+        /// </summary>
+        /// <param name="cacheSize">Maximum number of entries in the cache. Default is 1000.</param>
+        /// <param name="cacheTtl">Time-to-live for cache entries. Default is 30 minutes.</param>
+        public CmabConfig(int? cacheSize = null, TimeSpan? cacheTtl = null)
+        {
+            CacheSize = cacheSize;
+            CacheTtl = cacheTtl;
+            CustomCache = null;
+        }
+
+        /// <summary>
+        ///     Initializes a new instance of the CmabConfig class with a custom cache implementation.
+        /// </summary>
+        /// <param name="customCache">Custom cache implementation for CMAB decisions.</param>
+        public CmabConfig(ICache<CmabCacheEntry> customCache)
+        {
+            CustomCache = customCache ?? throw new ArgumentNullException(nameof(customCache));
+            CacheSize = null;
+            CacheTtl = null;
+        }
+
+        /// <summary>
+        ///     Gets the maximum number of entries in the CMAB cache.
+        ///     If null, the default value (1000) will be used.
+        /// </summary>
+        public int? CacheSize { get; }
+
+        /// <summary>
+        ///     Gets the time-to-live for CMAB cache entries.
+        ///     If null, the default value (30 minutes) will be used.
+        /// </summary>
+        public TimeSpan? CacheTtl { get; }
+
+        /// <summary>
+        ///     Gets the custom cache implementation for CMAB decisions.
+        ///     If provided, CacheSize and CacheTtl will be ignored.
+        /// </summary>
+        public ICache<CmabCacheEntry> CustomCache { get; }
+    }
+}

OptimizelySDK/Cmab/CmabConfig.cs

@@ -1,38 +1,46 @@
-/* 
-* Copyright 2025, Optimizely
-*
-* 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.
-*/
+/*
+ * Copyright 2025, Optimizely
+ *
+ * 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.
+ */
 
 using System;
 
 namespace OptimizelySDK.Cmab
 {
     internal static class CmabConstants
     {
-        public const string PredictionUrl = "https://prediction.cmab.optimizely.com/predict";
-        public static readonly TimeSpan MaxTimeout = TimeSpan.FromSeconds(10);
-
-        public const string ContentTypeJson = "application/json";
-
-        public const string ErrorFetchFailedFmt = "CMAB decision fetch failed with status: {0}";
-        public const string ErrorInvalidResponse = "Invalid CMAB fetch response";
-        public const string ExhaustRetryMessage = "Exhausted all retries for CMAB request";
-        
-        // Decision service messages
-        public const string UserNotInCmabExperiment = "User [{0}] not in CMAB experiment [{1}] due to traffic allocation.";
-        public const string CmabFetchFailed = "Failed to fetch CMAB decision for experiment [{0}].";
-        public const string CmabDecisionFetched = "CMAB decision fetched for user [{0}] in experiment [{1}].";
-        public const string CmabExperimentNotProperlyConfigured = "CMAB experiment [{0}] is not properly configured.";
+        public const string PREDICTION_URL = "https://prediction.cmab.optimizely.com/predict";
+        public const int DEFAULT_CACHE_SIZE = 10_000;
+        public const string CONTENT_TYPE = "application/json";
+
+        public const string ERROR_FETCH_FAILED_FMT = "CMAB decision fetch failed with status: {0}";
+        public const string ERROR_INVALID_RESPONSE = "Invalid CMAB fetch response";
+        public const string EXHAUST_RETRY_MESSAGE = "Exhausted all retries for CMAB request";
+
+        public const string USER_NOT_IN_CMAB_EXPERIMENT =
+            "User [{0}] not in CMAB experiment [{1}] due to traffic allocation.";
+
+        public const string CMAB_FETCH_FAILED =
+            "Failed to fetch CMAB decision for experiment [{0}].";
+
+        public const string CMAB_DECISION_FETCHED =
+            "CMAB decision fetched for user [{0}] in experiment [{1}].";
+
+        public const string CMAB_EXPERIMENT_NOT_PROPERLY_CONFIGURED =
+            "CMAB experiment [{0}] is not properly configured.";
+
+        public static readonly TimeSpan MAX_TIMEOUT = TimeSpan.FromSeconds(10);
+        public static readonly TimeSpan DEFAULT_CACHE_TTL = TimeSpan.FromMinutes(10);
     }
 }