Refactor CMAB cache settings and add convenience methods for cache size and TTL configuration

Author: FarhanAnjum-opti

optimizely/cmab/cmab_client.py

@@ -20,7 +20,7 @@
 from optimizely.exceptions import CmabFetchError, CmabInvalidResponseError
 
 # Default constants for CMAB requests
-DEFAULT_MAX_RETRIES = 3
+DEFAULT_MAX_RETRIES = 1
 DEFAULT_INITIAL_BACKOFF = 0.1  # in seconds (100 ms)
 DEFAULT_MAX_BACKOFF = 10  # in seconds
 DEFAULT_BACKOFF_MULTIPLIER = 2.0

optimizely/cmab/cmab_service.py

@@ -23,7 +23,10 @@
 from optimizely.decision.optimizely_decide_option import OptimizelyDecideOption
 from optimizely import logger as _logging
 from optimizely.lib import pymmh3 as mmh3
+
 NUM_LOCK_STRIPES = 1000
+DEFAULT_CMAB_CACHE_TIMEOUT = 30 * 60  # 30 minutes
+DEFAULT_CMAB_CACHE_SIZE = 1000
 
 
 class CmabDecision(TypedDict):
@@ -111,9 +114,13 @@ def _get_decision(self, project_config: ProjectConfig, user_context: OptimizelyU
                 if self.logger:
                     self.logger.debug(reason)
                 reasons.append(reason)
-                return CmabDecision(variation_id=cached_value['variation_id'], cmab_uuid=cached_value['cmab_uuid']), reasons
+                return CmabDecision(variation_id=cached_value['variation_id'],
+                                    cmab_uuid=cached_value['cmab_uuid']), reasons
             else:
-                reason = f"CMAB cache attributes mismatch for user '{user_context.user_id}' and rule '{rule_id}', fetching new decision."
+                reason = (
+                    f"CMAB cache attributes mismatch for user '{user_context.user_id}' "
+                    f"and rule '{rule_id}', fetching new decision."
+                )
                 if self.logger:
                     self.logger.debug(reason)
                 reasons.append(reason)

optimizely/optimizely.py

@@ -46,17 +46,13 @@
 from .optimizely_user_context import OptimizelyUserContext, UserAttributes
 from .project_config import ProjectConfig
 from .cmab.cmab_client import DefaultCmabClient, CmabRetryConfig
-from .cmab.cmab_service import DefaultCmabService, CmabCacheValue
+from .cmab.cmab_service import DefaultCmabService, CmabCacheValue, DEFAULT_CMAB_CACHE_SIZE, DEFAULT_CMAB_CACHE_TIMEOUT
 
 if TYPE_CHECKING:
     # prevent circular dependency by skipping import at runtime
     from .user_profile import UserProfileService
     from .helpers.event_tag_utils import EventTags
 
-# Default constants for CMAB cache
-DEFAULT_CMAB_CACHE_TIMEOUT = 30 * 60 * 1000  # 30 minutes in milliseconds
-DEFAULT_CMAB_CACHE_SIZE = 1000
-
 
 class Optimizely:
     """ Class encapsulating all SDK functionality. """
@@ -77,6 +73,7 @@ def __init__(
             default_decide_options: Optional[list[str]] = None,
             event_processor_options: Optional[dict[str, Any]] = None,
             settings: Optional[OptimizelySdkSettings] = None,
+            cmab_service: Optional[DefaultCmabService] = None,
     ) -> None:
         """ Optimizely init method for managing Custom projects.
 
@@ -178,16 +175,20 @@ def __init__(
         self.event_builder = event_builder.EventBuilder()
 
         # Initialize CMAB components
-        self.cmab_client = DefaultCmabClient(
-            retry_config=CmabRetryConfig(),
-            logger=self.logger
-        )
-        self.cmab_cache: LRUCache[str, CmabCacheValue] = LRUCache(DEFAULT_CMAB_CACHE_SIZE, DEFAULT_CMAB_CACHE_TIMEOUT)
-        self.cmab_service = DefaultCmabService(
-            cmab_cache=self.cmab_cache,
-            cmab_client=self.cmab_client,
-            logger=self.logger
-        )
+        if cmab_service:
+            self.cmab_service = cmab_service
+        else:
+            self.cmab_client = DefaultCmabClient(
+                retry_config=CmabRetryConfig(),
+                logger=self.logger
+            )
+            self.cmab_cache: LRUCache[str, CmabCacheValue] = LRUCache(DEFAULT_CMAB_CACHE_SIZE,
+                                                                      DEFAULT_CMAB_CACHE_TIMEOUT)
+            self.cmab_service = DefaultCmabService(
+                cmab_cache=self.cmab_cache,
+                cmab_client=self.cmab_client,
+                logger=self.logger
+            )
         self.decision_service = decision_service.DecisionService(self.logger, user_profile_service, self.cmab_service)
         self.user_profile_service = user_profile_service
 

optimizely/optimizely_factory.py

@@ -22,6 +22,9 @@
 from .event_dispatcher import EventDispatcher, CustomEventDispatcher
 from .notification_center import NotificationCenter
 from .optimizely import Optimizely
+from .odp.lru_cache import LRUCache
+from .cmab.cmab_client import DefaultCmabClient, CmabRetryConfig
+from .cmab.cmab_service import DefaultCmabService, DEFAULT_CMAB_CACHE_TIMEOUT, DEFAULT_CMAB_CACHE_SIZE
 
 if TYPE_CHECKING:
     # prevent circular dependenacy by skipping import at runtime
@@ -36,6 +39,9 @@ class OptimizelyFactory:
     max_event_flush_interval: Optional[int] = None
     polling_interval: Optional[float] = None
     blocking_timeout: Optional[int] = None
+    cmab_cache_size: Optional[int] = None
+    cmab_cache_ttl: Optional[int] = None
+    cmab_custom_cache: Optional[LRUCache] = None
 
     @staticmethod
     def set_batch_size(batch_size: int) -> int:
@@ -75,6 +81,51 @@ def set_blocking_timeout(blocking_timeout: int) -> int:
         OptimizelyFactory.blocking_timeout = blocking_timeout
         return OptimizelyFactory.blocking_timeout
 
+    @staticmethod
+    def set_cmab_cache_size(cache_size: int, logger: Optional[optimizely_logger.Logger] = None) -> Optional[int]:
+        """ Convenience method for setting the maximum number of items in CMAB cache.
+        Args:
+          cache_size: Maximum number of items in CMAB cache.
+          logger: Optional logger for logging messages.
+        """
+        logger = logger or optimizely_logger.NoOpLogger()
+
+        if not isinstance(cache_size, int) or cache_size <= 0:
+            logger.error(
+                f"CMAB cache size is invalid, setting to default size {DEFAULT_CMAB_CACHE_SIZE}."
+            )
+            return None
+
+        OptimizelyFactory.cmab_cache_size = cache_size
+        return OptimizelyFactory.cmab_cache_size
+
+    @staticmethod
+    def set_cmab_cache_ttl(cache_ttl: int, logger: Optional[optimizely_logger.Logger] = None) -> Optional[int]:
+        """ Convenience method for setting CMAB cache TTL.
+        Args:
+          cache_ttl: Time in seconds for cache entries to live.
+          logger: Optional logger for logging messages.
+        """
+        logger = logger or optimizely_logger.NoOpLogger()
+
+        if not isinstance(cache_ttl, (int, float)) or cache_ttl <= 0:
+            logger.error(
+                f"CMAB cache TTL is invalid, setting to default TTL {DEFAULT_CMAB_CACHE_TIMEOUT}."
+            )
+            return None
+
+        OptimizelyFactory.cmab_cache_ttl = int(cache_ttl)
+        return OptimizelyFactory.cmab_cache_ttl
+
+    @staticmethod
+    def set_cmab_custom_cache(custom_cache: LRUCache) -> LRUCache:
+        """ Convenience method for setting custom CMAB cache.
+        Args:
+          custom_cache: Cache implementation with lookup, save, remove, and reset methods.
+        """
+        OptimizelyFactory.cmab_custom_cache = custom_cache
+        return OptimizelyFactory.cmab_custom_cache
+
     @staticmethod
     def default_instance(sdk_key: str, datafile: Optional[str] = None) -> Optimizely:
         """ Returns a new optimizely instance..
@@ -104,9 +155,17 @@ def default_instance(sdk_key: str, datafile: Optional[str] = None) -> Optimizely
             notification_center=notification_center,
         )
 
+        # Initialize CMAB components
+        cmab_client = DefaultCmabClient(retry_config=CmabRetryConfig(), logger=logger)
+        cmab_cache = OptimizelyFactory.cmab_custom_cache or LRUCache(
+            OptimizelyFactory.cmab_cache_size or DEFAULT_CMAB_CACHE_SIZE,
+            OptimizelyFactory.cmab_cache_ttl or DEFAULT_CMAB_CACHE_TIMEOUT
+        )
+        cmab_service = DefaultCmabService(cmab_cache, cmab_client, logger)
+
         optimizely = Optimizely(
             datafile, None, logger, error_handler, None, None, sdk_key, config_manager, notification_center,
-            event_processor
+            event_processor, cmab_service=cmab_service
         )
         return optimizely
 
@@ -174,7 +233,16 @@ def custom_instance(
             notification_center=notification_center,
         )
 
+        # Initialize CMAB components
+        cmab_client = DefaultCmabClient(retry_config=CmabRetryConfig(), logger=logger)
+        cmab_cache = OptimizelyFactory.cmab_custom_cache or LRUCache(
+            OptimizelyFactory.cmab_cache_size or DEFAULT_CMAB_CACHE_SIZE,
+            OptimizelyFactory.cmab_cache_ttl or DEFAULT_CMAB_CACHE_TIMEOUT
+        )
+        cmab_service = DefaultCmabService(cmab_cache, cmab_client, logger)
+
         return Optimizely(
             datafile, event_dispatcher, logger, error_handler, skip_json_validation, user_profile_service,
-            sdk_key, config_manager, notification_center, event_processor, settings=settings
+            sdk_key, config_manager, notification_center, event_processor, settings=settings,
+            cmab_service=cmab_service
         )