Decide methods for the Ruby SDK
Use the decide methods to return feature flag decisions for a user. Each decision includes whether the flag is enabled and which variation the user receives.
Decide
Returns a decision for a specific feature flag and user.
Minimum SDK version – v3.8+
Description
The decide method handles the variation decision for an individual experiment. It returns a decision result for a flag key for a user in an OptimizelyDecision object and contains the data required to deliver the flag rule.
This method ensures that Feature Experimentation properly buckets the user in experiment analytics, and you should use it if there is no need for pre-rendering decisions.
Decide is a method of the UserContext object. See OptimizelyUserContext for details.
See the OptimizelyDecision for details of the returned decision object.
Key features
- Single experiment decision – Returns the variation for a specific experiment.
- Bucketing in results – Ensures Feature Experimentation records the user in the experiment results page for proper analysis.
- Complement to decide all method – If you use the decide all method to pre-fetch variations, you should also call the decide method for each experiment that the user interacts with. This dual approach guarantees that Feature Experimentation accurately tracks the user's participation and that the correct variation is served through caching.
- CMAB support – For CMAB experiments, decisions are automatically cached to reduce latency. The cache is invalidated when CMAB attributes change or TTL expires. Use CMAB-specific decide options (IGNORE_CMAB_CACHE, INVALIDATE_USER_CMAB_CACHE, and RESET_CMAB_CACHE) to override default caching behavior. See the following CMAB cache control information.
Parameters
The following table describes parameters for the Decide method:
Parameter | Type | Description |
|---|---|---|
key | String | The key of the feature flag |
options (optional) | Array | Array of OptimizelyDecideOption enums. |
Returns
The decide method returns an OptimizelyDecision object.
If the method encounters a critical error (SDK not ready, invalid flag key, and so on), then it returns a decision with a nil variation_key field and populates the reasons field with error messages (regardless of the INCLUDE_REASONS option).
Example decide
# Create the user and decide which flag rule and variation they bucket into
user = optimizely.create_user_context(user_id, attributes)
decision = user.decide('product_sort')
# The variation key. If nil, decision fail with a critical error
variation_key = decision.variation_key
# The flag enabled state
enabled = decision.enabled
# The string variable value
value = decision.variables['logged_in'].to_s
# All variable values
all_var_values = decision.variables
# Flag decision reasons
reasons = decision.reasons
# The user for which the decision was made
user_context = decision.user_contextSide effect
Invokes the decision notification listener if this listener is enabled.
Decide all
Returns decisions for all active (unarchived) flags for a user.
Minimum SDK version – v3.7+
Description
Use the decide all method to retrieve decisions for all active flags before rendering content. This is particularly useful when you need to serve the correct cached version of your page or component based on the user's variation. For example when using an edge worker or cloud function.
Key features
- Pre-rendering decision – Lets you know all variation assignments ahead of time.
- Cache control – Lets you serve the correct cached content based on the user's pre-determined variations.
- Delay experiment tracking – Use DISABLE_DECISION_EVENT to prevent the SDK from recording a decision before the user sees the feature. This ensures that participation is only tracked when the experience is delivered.
- CMAB support – For CMAB experiments (SDK v5.2.0+), decisions are automatically cached to reduce latency. The cache is invalidated when CMAB attributes change or TTL expires. Use CMAB-specific decide options (ignoreCmabCache, invalidateUserCmabCache, resetCmabCache) to override default caching behavior. See CMAB cache control.
Parameters
The following table describes parameters for the decide all method:
Parameter | Type | Description |
|---|---|---|
options (optional) | Array | Array of OptimizelyDecideOption enums. |
Returns
The decide all method returns a map of OptimizelyDecisions. For information, see OptimizelyDecision.
If the method fails for all flags (for example, the SDK is not ready or the user context is invalid), then it returns an empty map. If the method detects an error for a specific flag, it returns error messages in the reasons field of the decision for that flag.
Example decide_all
# Make decisions for all active (unarchived) flags in the project for a user
decisions = user.decide_all()
# Or only for enabled flags
decisions = user.decide_all([Optimizely::Decide::OptimizelyDecideOption::ENABLED_FLAGS_ONLY])
decision_for_flag1 = decisions['flag_1']Side effect
Invokes the decision notification listener for each decision, if this listener is enabled.
Decide for keys
Returns a map of flag decisions for specified flag keys.
Minimum SDK version – v3.7+
Description
Returns a map of decisions for the specified flag keys.
Parameters
The following table describes parameters for the decide for keys method:
Parameter | Type | Description |
|---|---|---|
keys | Array | Array of string flag keys. |
options (optional) | Array | Array of OptimizelyDecideOption enums. |
Returns
Returns a map of OptimizelyDecisions. For information, see OptimizelyDecision.
If the method fails for all flags (for example, the SDK is not ready or the user context is invalid), then it returns an empty map. If the method detects an error for a specific flag, it returns error messages in the reasons field of the decision for that flag.
Example decide_for_keys
# make a decisions for specific enabled flags
options = [Optimizely::Decide::OptimizelyDecideOption::ENABLED_FLAGS_ONLY]
decisions = user.decide_for_keys(['flag_1', 'flag_2'], options)
decision_for_flag1 = decisions['flag_1']
decision_for_flag2 = decisions['flag_2']Side effect
Invokes the decision notification listener for each decision, if this listener is enabled.
OptimizelyDecideOption
The following table lists the OptimizelyDecideOption enum with an explanation what happens if you set them. In addition to setting these options individually for a decide method, you can also set them as global defaults when you instantiate the Optimizely client. See Initialize the Ruby SDK.
`OptimizelyDecideOption` enum | If set |
|---|---|
`DISABLE_DECISION_EVENT` | Prevents the SDK from dispatching an [impression](https://support.optimizely.com/hc/en-us/articles/38932560874765) event when serving a variation. This disables decision tracking on the [Optimizely Experiment Results page](https://support.optimizely.com/hc/en-us/articles/4410284017421) and the [decision notification listener](https://docs.developers.optimizely.com/feature-experimentation/docs/decision-notification-listener). |
`ENABLED_FLAGS_ONLY` | Returns decisions only for flags that are currently enabled. Used with the [decide all method](#decide-all) and [decide for keys method](#decide-for-keys). When this option is not set, the Ruby SDK returns all decisions regardless of whether the flag is enabled. |
`IGNORE_USER_PROFILE_SERVICE` | Bypasses the user profile service (both lookup and save) for the decision. When this option is not set, user profile service overrides audience targeting, traffic allocation, and experiment mutual exclusion groups. |
`INCLUDE_REASONS` | Adds log messages to the reasons field of the decision. Critical errors are always returned, even if this option is not set. |
`EXCLUDE_VARIABLES` | Excludes flag variable values from the decision result. Use this option to minimize the returned decision by skipping large JSON variables. |
`OptimizelyDecideOption.IGNORE_CMAB_CACHE` | Bypasses the CMAB cache and fetches a fresh decision from the CMAB service. Use when you need real-time decisions that reflect the latest context. |
`OptimizelyDecideOption.INVALIDATE_USER_CMAB_CACHE` | Removes the cached CMAB decision for this user and experiment before making the decision. Use when user context has changed significantly and you want to ensure a fresh decision. |
`OptimizelyDecideOption.RESET_CMAB_CACHE` | Clears all entries from the CMAB cache before making the decision. Use sparingly for testing or cache corruption scenarios. |
The following code sample shows how to implement the OptimizelyDecideOption as a global default and locally in a decide method call.
require 'optimizely'
# Set global default decide options when initializing the client
optimizely_client = Optimizely::Project.new(
sdk_key: 'YOUR_SDK_KEY', # Replace with your SDK key
default_decide_options: [Optimizely::Decide::OptimizelyDecideOption::DISABLE_DECISION_EVENT]
)
user = optimizely_client.create_user_context('test_user')
user.decide_all(
[Optimizely::Decide::OptimizelyDecideOption::ENABLED_FLAGS_ONLY,
Optimizely::Decide::OptimizelyDecideOption::IGNORE_USER_PROFILE_SERVICE]
)Best practices
- Early and late invocation
- Use the decide all method early in your application's rendering process to load the correct cached content. For example, on the CDN with an Edge SDK.
- Use the decide method at the point of user interaction or when you must ensure Feature Experimentation records the decision in your experiment analytics.
- Combining methods – When using the decide and decide all methods, always pair the decide all method with the decide method for each experiment the user encounters. This prevents discrepancies between served content and analytics data.
- Parameter management – Ensure you use the DISABLE_DECISION_EVENT option with the decide all method to avoid premature bucketing, then use the decide method to handle the decision event when the user experiences the content.
CMAB cache control
Minimum Ruby SDK version – v5.2.0+
For Contextual Multi-Armed Bandit (CMAB) experiments, the Ruby SDK automatically caches variation assignments to reduce latency and API calls. The cache stores decisions based on user ID, experiment ID, and CMAB attribute values.
Automatic cache invalidation
The cache is automatically invalidated when
- The cached entry's TTL expires (default: 30 minutes).
- CMAB attribute values change for a user (detected through attribute hash comparison).
Manual cache control
Use CMAB-specific decide options to control cache behavior on a per-decision basis, like in the following example:
require 'optimizely'
require 'optimizely/decide/optimizely_decide_option'
optimizely_client = Optimizely::OptimizelyFactory.custom_instance(
'YOUR_SDK_KEY',
nil,
nil,
Optimizely::SimpleLogger.new
)
# Example 1 – Bypass cache for real-time decision.
user = optimizely_client.create_user_context('user123', {
'age' => 25,
'location' => 'US'
})
decision = user.decide('my-cmab-flag', [
Optimizely::OptimizelyDecideOption::IGNORE_CMAB_CACHE # Always fetch fresh from CMAB service.
])
# Example 2 – Invalidate cache when user context changes significantly.
user = optimizely_client.create_user_context('user123', {
'age' => 26,
'location' => 'UK' # Context changed.
})
decision = user.decide('my-cmab-flag', [
Optimizely::OptimizelyDecideOption::INVALIDATE_USER_CMAB_CACHE # Clear cached decision for this user.
])
# Example 3 – Reset entire CMAB cache (use sparingly).
decision = user.decide('my-cmab-flag', [
Optimizely::OptimizelyDecideOption::RESET_CMAB_CACHE # Clear all CMAB cache entries.
])CMAB decision reasons
When using INCLUDE_REASONS, CMAB-related information appears in the decision's Reasons field.
decision = user.decide('my-cmab-flag', [
Optimizely::OptimizelyDecideOption::INCLUDE_REASONS
])
# Print CMAB-related decision reasons
decision.reasons.each do |reason|
puts reason
# Examples:
# "CMAB cache hit for user 'user123' and rule 'exp_001'."
# "CMAB cache miss for user 'user123' and rule 'exp_001'."
# "CMAB cache attributes mismatch for user 'user123' and rule 'exp_001', fetching new decision."
# "Ignoring CMAB cache for user 'user123' and rule 'exp_001'."
# "Resetting CMAB cache for user 'user123' and rule 'exp_001'."
# "Invalidating CMAB cache for user 'user123' and rule 'exp_001'."
# "CMAB decision is {:variation_id=>\"var_1\", :cmab_uuid=>\"uuid-123\"}"
endConfigure CMAB cache settings (size and TTL) at client initialization time. See Initialize the Ruby SDK and Configure the CMAB cache for the Ruby SDK for details.
Source files
The language and platform source files containing the implementation for Ruby are available on GitHub.