Fast and easy feature flags based on Redis.
Based on the discontinued rollout project, removing some capabilities, including some new features and supporting latest Redis versions.
Topics covered in this README:
gem install rollout-redis
Instantiate the Rollout class sending a Redis instance as a parameter.
require 'redis'
require 'rollout'
@redis ||= Redis.new(
host: ENV.fetch('REDIS_HOST'),
port: ENV.fetch('REDIS_PORT')
)
@rollout ||= Rollout.new(@redis)
Now you can activate Feature Flags:
@rollout.activate('FEATURE_FLAG_NAME') # => true/false
Verify if a feature is currently enabled:
if @rollout.active?('FEATURE_FLAG_NAME')
# your new code here...
end
An alternative to the if check, is to wrap your code under the with_feature method. The wrapped code will be performed only if the feature flag is active:
@rollout.with_feature('FEATURE_FLAG_NAME') do
# your new code here...
end
If there is an issue, you have the option to disable a feature:
@rollout.deactivate('FEATURE_FLAG_NAME')
If you want to list all the stored feature flags, you can use the features method:
@rollout.features
The response will be an array of hashes with all the information about the stored feature flags
[
{ name: 'a-feature-flag', percentage: 100, data: { requests: 50, errors: 1 } },
{ name: 'another-feature-flag', percentage: 20, data: { requests: 1, errors: 0 } },
{ name: 'super-feature-flag', percentage: 50, data: { requests: 828, errors: 34 } }
]
When introducing a new feature, it's a recommended practice to gradually enable it for a specific portion of your target audience to evaluate its impact. To achieve this, you can utilize the activate method, as shown below:
@rollout.activate('FEATURE_FLAG_NAME', 20)
Now, to know if a feature flags is enabled, you need to provide a determinator (in this example, we're using the user email):
if @rollout.active?('FEATURE_FLAG_NAME', user_email)
# your new code here...
end
The gradual activation also works wrapping your code within the with_feature method, you just need to provde the determinator you want to use.
@rollout.with_feature('FEATURE_FLAG_NAME', user_email) do
# your new code here...
end
It's important to note that if you use the active? method without specifying a determinator to determine whether this subset of the audience should see the new feature, it will always return false since the activation percentage is less than 100%. See:
@rollout.activate('FEATURE_FLAG_NAME', 20)
@rollout.active?('FEATURE_FLAG_NAME') # => false
The Rollout gem is tightly integrated with Redis for feature flag status management. Consequently, occasional connectivity issues between your application and the Redis storage may arise.
To prevent potential application degradation when the Redis storage is unavailable, you can enable feature flag status caching during the gem's instantiation:
@rollout ||= Rollout.new(redis).with_cache
Additionally, you can specify extra parameters to configure the duration (in seconds) for which the feature flag status is stored in the cache. By default, this duration is set to 300 seconds (5 minutes):
@rollout ||= Rollout.new(redis)
.with_cache(expires_in: 300)
In the case that you need to clear the cache at any point, you can make use of the clean_cache method:
@rollout.clean_cache
If you want to allow the gem to deactivate all the feature flags automatically when a threshold of errors is reached, you can enable the degrade feature using the with_degrade method.
@rollout ||= Rollout.new(redis)
.with_cache
.with_degrade(min: 100, threshold: 0.1)
However, if you just want to activate the degradation of an specific feature flag, you need to provide the following information when activating the feature flag (note that now the percentage is a mandatory parameter if you want to pass the degrade options):
@rollout.activate('FEATURE_FLAG_NAME', 100, degrade: { min: 500, threshold: 0.2 })
The same configuration 👆 is available when using the rake task for activating the feature flag. Check Rake tasks section.
bundle exec rake rollout:on[FEATURE_FLAG_NAME,100,500,0.2]
So now, instead of using the active? method, you need to wrap your new code under the with_feature method.
@rollout.with_feature('FEATURE_FLAG_NAME') do
# your new feature code here...
end
When any unexpected error appears during the wrapped code execution, the Rollout gem will take it into account for automatically degrading the feature flag if the threshold of errors is reached. The feature flag will not be removed from the redis, but it will change its percentage to 0 and it will be marked as degraded.
NOTE: All the managed or captured errors inside the wrapped code will not be taken into consideration for degrading the feature flag.
rollout-redis gem can send different notifications to your development team. For enabling this feature, you just need to use the with_notifications instance method providing the channels where you want to publish each of the different events that can occur:
rollout-redis gem.with_degrade instance method.You must provide at least one channel as a parameter if you want to enable the notifications for that specific event. If no channels provided, the notifications will not be sent.
@rollout ||= Rollout.new(redis)
.with_cache
.with_degrade(min: 100, threshold: 0.1)
.with_notifications(
status_change: [slack_channel],
degrade: [slack_channel, email_channel]
)
When enabling a notification, you can provide the different channels where the notification should be published. rollout-redis gem offers different channels that can be configured.
Allows you to send notifications using a slack webhook.
The first thing to do is to setup an incoming webhook service integration. You can do this from your services page.
After that, you can provide the obtained webhook url when instantiating the Slack channel.
require 'rollout'
slack_channel = Rollout::Notifications::Channels::Slack.new(
webhook_url: ENV.fetch('SLACK_COMPANY_WEBHOOK_URL'),
channel: '#feature-flags-notifications',
username: 'rollout-redis'
)
Allows you to send notifications via email.
require 'rollout'
email_channel = Rollout::Notifications::Channels::Email.new(
smtp_host: ENV.fetch('SMTP_HOST'),
smtp_port: ENV.fetch('SMTP_PORT'),
from: 'no-reply@rollout-redis.com',
to: 'developers@yourcompany.com'
)
If you want to send the notifications using a different channel not offered by this gem, you can implement your own class with a publish method.
require 'rollout'
module YourApp
class YourCustomChannel
def initialize()
# provide here whatever you need for configuring your channel
end
def publish(text)
# Implement the way you want to publish the notification
end
end
end
After implementing it, you can pass it to the list of configured channels
your_channel = YourApp::YourCustomChannel.new(url: 'wadus', param2: 'foo')
@rollout ||= Rollout.new(redis)
.with_cache
.with_degrade(min: 100, threshold: 0.1)
.with_notifications(
status_change: [your_channel],
degrade: [your_channel]
)
In order to have access to the rollout rakes, you have to load manually the task definitions. For doing so load the rollout rake task:
require 'rollout'
load 'rollout/tasks/rollout.rake'
Also, for using the rake tasks, you must set the following env variables
ROLLOUT_REDIS_HOST=localhost
ROLLOUT_REDIS_PORT=6379
To activate/deactivate features, execute the following rake tasks:
bundle exec rake rollout:on[feature_name]
bundle exec rake rollout:off[feature_name]
To a gradual activation based on percentages, pass the percentage as the second parameter when executing the on task.
bundle exec rake rollout:on[feature_name,50]
NOTE: In both cases, feature_name must not include quotes e.g. bundle exec rake rollout:on['feature_name'], as the gem will be unable to fetch its activation status if so.
For listing all the stored feature flags, do:
bundle exec rake rollout:list
For migrating feature flags stored using the old rollout gem format (check migration guide), do:
bundle exec rake rollout:migrate_from_rollout_format
If you are currently using the unmaintained rollout gem, you should consider checking this migration guide for start using the new rollout-redis gem.
You can use the .with_old_rollout_gem_compatibility instance method for making the rollout-redis gem work as the the discontinued rollout gem in terms of redis storage and format storage. Check the migration guide for more information.
If you're interested in seeing the changes and bug fixes between each version of rollout-redis, read the Changelog.
We welcome and appreciate contributions from the open-source community. Before you get started, please take a moment to review the guidelines below.
This project is dockerized, so be sure you have docker installed in your machine.
Once you clone the repository, you can use the Make commands to build the project.
make build
You can pass the tests running:
make test
Open issues on the GitHub issue tracker with clear information.
The rollout-redis gem is based on the discontinued rollout project, created by James Golick
FAQs
Unknown package
We found that rollout-redis demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
PyPI confirms no security flaws were exploited in the Ultralytics supply chain attack and highlights improvements for safer package publishing.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.