rollout 2.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 37e56080ba30fb08aaa7e718e22fae3cab0745e84a91537e4e5520c2843a63a2
+  data.tar.gz: 2b2f8c5a6e7a3ddd8275d818b4a168e7573204c2e259e323ca7a2ea9996062d9
+SHA512:
+  metadata.gz: a31905463a16ca7413566460c9a693ab5b9063e74547c05aafe2cf40d5e8f8d83ecb9e85316dd48c3e6b5e5b63311ac222343b485228a695ff5b72f8b0d82a2c
+  data.tar.gz: 33fc542bdfe0def2b13a1b3697ba59c1e5f83e813a7c67740d94bf0a9725e17003fdc3fecfa923874883730dde589e0906b5d49ab19ff49c36943e259c28f134

data/.circleci/config.yml

@@ -0,0 +1,95 @@
+version: 2.1
+
+workflows:
+  main:
+    jobs:
+      - ruby27
+      - ruby26
+      - ruby25
+      - ruby24
+      - ruby23
+
+executors:
+  ruby27:
+    docker:
+      - image: circleci/ruby:2.7
+      - image: circleci/redis:alpine
+  ruby26:
+    docker:
+      - image: circleci/ruby:2.6
+      - image: circleci/redis:alpine
+  ruby25:
+    docker:
+      - image: circleci/ruby:2.5
+      - image: circleci/redis:alpine
+  ruby24:
+    docker:
+      - image: circleci/ruby:2.4
+      - image: circleci/redis:alpine
+  ruby23:
+    docker:
+      - image: circleci/ruby:2.3
+      - image: circleci/redis:alpine
+
+commands:
+  test:
+    steps:
+      - restore_cache:
+          keys:
+            - bundler-{{ checksum "Gemfile.lock" }}
+
+      - run:
+          name: Bundle Install
+          command: bundle check --path vendor/bundle || bundle install
+
+      - save_cache:
+          key: bundler-{{ checksum "Gemfile.lock" }}
+          paths:
+            - vendor/bundle
+
+      - run:
+          name: Run rspec
+          command: |
+            bundle exec rspec --format documentation --format RspecJunitFormatter --out test_results/rspec.xml
+
+jobs:
+  ruby27:
+    executor: ruby27
+    steps:
+      - checkout
+      - test
+
+      - run:
+          name: Report Test Coverage
+          command: |
+            wget https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 -O cc-test-reporter
+            chmod +x cc-test-reporter
+            ./cc-test-reporter format-coverage -t simplecov -o coverage/codeclimate.json coverage/.resultset.json
+            ./cc-test-reporter upload-coverage -i coverage/codeclimate.json
+
+      - store_test_results:
+          path: test_results
+
+  ruby26:
+    executor: ruby26
+    steps:
+      - checkout
+      - test
+
+  ruby25:
+    executor: ruby25
+    steps:
+      - checkout
+      - test
+
+  ruby24:
+    executor: ruby24
+    steps:
+      - checkout
+      - test
+
+  ruby23:
+    executor: ruby23
+    steps:
+      - checkout
+      - test

data/.gitignore

@@ -0,0 +1,24 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+*.gem
+gemfiles/*.lock
+.rspec_status
+
+## PROJECT::SPECIFIC

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/LineLength:
+  Max: 120
+Metrics/MethodLength:
+  Max: 20
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -0,0 +1,20 @@
+language: ruby
+cache: bundler
+sudo: false
+services:
+  - redis-server
+rvm:
+  - 2.6
+  - 2.5
+  - 2.4
+  - 2.3
+  - 2.2
+  - 2.1
+  - 2.0
+env:
+  - USE_REAL_REDIS=true
+gemfile:
+  - gemfiles/redis_3.gemfile
+  - gemfiles/redis_4.gemfile
+script:
+  - bundle exec rspec

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-InfinityAndBeyond BitLove, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,201 @@
+# rollout
+
+Fast feature flags based on Redis.
+
+[![Gem Version](https://badge.fury.io/rb/rollout.svg)](https://badge.fury.io/rb/rollout)
+[![CircleCI](https://circleci.com/gh/fetlife/rollout.svg?style=svg)](https://circleci.com/gh/fetlife/rollout)
+[![Code Climate](https://codeclimate.com/github/FetLife/rollout/badges/gpa.svg)](https://codeclimate.com/github/FetLife/rollout)
+[![Test Coverage](https://codeclimate.com/github/FetLife/rollout/badges/coverage.svg)](https://codeclimate.com/github/FetLife/rollout/coverage)
+
+## Install it
+
+```bash
+gem install rollout
+```
+
+## How it works
+
+Initialize a rollout object. I assign it to a global var.
+
+```ruby
+require 'redis'
+
+$redis = Redis.new
+$rollout = Rollout.new($redis)
+```
+
+or even simpler
+
+```ruby
+require 'redis'
+$rollout = Rollout.new(Redis.current) # Will use REDIS_URL env var or default redis url
+```
+
+
+Update data specific to a feature:
+
+```ruby
+$rollout.set_feature_data(:chat, description: 'foo', release_date: 'bar', whatever: 'baz')
+```
+
+Check whether a feature is active for a particular user:
+
+```ruby
+$rollout.active?(:chat, User.first) # => true/false
+```
+
+Check whether a feature is active globally:
+
+```ruby
+$rollout.active?(:chat)
+```
+
+You can activate features using a number of different mechanisms.
+
+## Groups
+
+Rollout ships with one group by default: "all", which does exactly what it
+sounds like.
+
+You can activate the all group for the chat feature like this:
+
+```ruby
+$rollout.activate_group(:chat, :all)
+```
+
+You might also want to define your own groups. We have one for our caretakers:
+
+```ruby
+$rollout.define_group(:caretakers) do |user|
+  user.caretaker?
+end
+```
+
+You can activate multiple groups per feature.
+
+Deactivate groups like this:
+
+```ruby
+$rollout.deactivate_group(:chat, :all)
+```
+
+Groups need to be defined every time your app starts. The logic is not persisted
+anywhere.
+
+## Specific Users
+
+You might want to let a specific user into a beta test or something. If that
+user isn't part of an existing group, you can let them in specifically:
+
+```ruby
+$rollout.activate_user(:chat, @user)
+```
+
+Deactivate them like this:
+
+```ruby
+$rollout.deactivate_user(:chat, @user)
+```
+
+## User Percentages
+
+If you're rolling out a new feature, you might want to test the waters by
+slowly enabling it for a percentage of your users.
+
+```ruby
+$rollout.activate_percentage(:chat, 20)
+```
+
+The algorithm for determining which users get let in is this:
+
+```ruby
+CRC32(user.id) < (2**32 - 1) / 100.0 * percentage
+```
+
+So, for 20%, users 0, 1, 10, 11, 20, 21, etc would be allowed in. Those users
+would remain in as the percentage increases.
+
+Deactivate all percentages like this:
+
+```ruby
+$rollout.deactivate_percentage(:chat)
+```
+
+_Note that activating a feature for 100% of users will also make it active
+"globally". That is when calling Rollout#active? without a user object._
+
+In some cases you might want to have a feature activated for a random set of
+users. It can come specially handy when using Rollout for split tests.
+
+```ruby
+$rollout = Rollout.new($redis, randomize_percentage: true)
+```
+
+When on `randomize_percentage` will make sure that 50% of users for feature A
+are selected independently from users for feature B.
+
+## Global actions
+
+While groups can come in handy, the actual global setter for a feature does not require a group to be passed.
+
+```ruby
+$rollout.activate(:chat)
+```
+
+In that case you can check the global availability of a feature using the following
+
+```ruby
+$rollout.active?(:chat)
+```
+
+And if something is wrong you can set a feature off for everybody using
+
+Deactivate everybody at once:
+
+```ruby
+$rollout.deactivate(:chat)
+```
+
+For many of our features, we keep track of error rates using redis, and
+deactivate them automatically when a threshold is reached to prevent service
+failures from cascading. See https://github.com/jamesgolick/degrade for the
+failure detection code.
+
+## Namespacing
+
+Rollout separates its keys from other keys in the data store using the
+"feature" keyspace.
+
+If you're using redis, you can namespace keys further to support multiple
+environments by using the
+[redis-namespace](https://github.com/resque/redis-namespace) gem.
+
+```ruby
+$ns = Redis::Namespace.new(Rails.env, redis: $redis)
+$rollout = Rollout.new($ns)
+$rollout.activate_group(:chat, :all)
+```
+
+This example would use the "development:feature:chat:groups" key.
+
+## Frontend / UI
+
+* [Rollout-Dashboard](https://github.com/fiverr/rollout_dashboard/)
+
+## Implementations in other languages
+
+*   Python: https://github.com/asenchi/proclaim
+*   PHP: https://github.com/opensoft/rollout
+*   Clojure: https://github.com/yeller/shoutout
+*   Perl: https://metacpan.org/pod/Toggle
+
+
+## Contributors
+
+*   James Golick - Creator - https://github.com/jamesgolick
+*   Eric Rafaloff - Maintainer - https://github.com/EricR
+
+
+## Copyright
+
+Copyright (c) 2010-InfinityAndBeyond BitLove, Inc. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/rollout.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'rollout/feature'
+require 'rollout/logging'
+require 'rollout/version'
+require 'zlib'
+require 'set'
+require 'json'
+require 'observer'
+
+class Rollout
+  include Observable
+
+  RAND_BASE = (2**32 - 1) / 100.0
+
+  attr_reader :options, :storage
+
+  def initialize(storage, opts = {})
+    @storage = storage
+    @options = opts
+    @groups  = { all: ->(_user) { true } }
+
+    extend(Logging) if opts[:logging]
+  end
+
+  def groups
+    @groups.keys
+  end
+
+  def activate(feature)
+    with_feature(feature) do |f|
+      f.percentage = 100
+    end
+  end
+
+  def deactivate(feature)
+    with_feature(feature, &:clear)
+  end
+
+  def delete(feature)
+    features = (@storage.get(features_key) || '').split(',')
+    features.delete(feature.to_s)
+    @storage.set(features_key, features.join(','))
+    @storage.del(key(feature))
+
+    if respond_to?(:logging)
+      logging.delete(feature)
+    end
+  end
+
+  def set(feature, desired_state)
+    with_feature(feature) do |f|
+      if desired_state
+        f.percentage = 100
+      else
+        f.clear
+      end
+    end
+  end
+
+  def activate_group(feature, group)
+    with_feature(feature) do |f|
+      f.add_group(group)
+    end
+  end
+
+  def deactivate_group(feature, group)
+    with_feature(feature) do |f|
+      f.remove_group(group)
+    end
+  end
+
+  def activate_user(feature, user)
+    with_feature(feature) do |f|
+      f.add_user(user)
+    end
+  end
+
+  def deactivate_user(feature, user)
+    with_feature(feature) do |f|
+      f.remove_user(user)
+    end
+  end
+
+  def activate_users(feature, users)
+    with_feature(feature) do |f|
+      users.each { |user| f.add_user(user) }
+    end
+  end
+
+  def deactivate_users(feature, users)
+    with_feature(feature) do |f|
+      users.each { |user| f.remove_user(user) }
+    end
+  end
+
+  def set_users(feature, users)
+    with_feature(feature) do |f|
+      f.users = []
+      users.each { |user| f.add_user(user) }
+    end
+  end
+
+  def define_group(group, &block)
+    @groups[group.to_sym] = block
+  end
+
+  def active?(feature, user = nil)
+    feature = get(feature)
+    feature.active?(self, user)
+  end
+
+  def user_in_active_users?(feature, user = nil)
+    feature = get(feature)
+    feature.user_in_active_users?(user)
+  end
+
+  def inactive?(feature, user = nil)
+    !active?(feature, user)
+  end
+
+  def activate_percentage(feature, percentage)
+    with_feature(feature) do |f|
+      f.percentage = percentage
+    end
+  end
+
+  def deactivate_percentage(feature)
+    with_feature(feature) do |f|
+      f.percentage = 0
+    end
+  end
+
+  def active_in_group?(group, user)
+    f = @groups[group.to_sym]
+    f&.call(user)
+  end
+
+  def get(feature)
+    string = @storage.get(key(feature))
+    Feature.new(feature, string, @options)
+  end
+
+  def set_feature_data(feature, data)
+    with_feature(feature) do |f|
+      f.data.merge!(data) if data.is_a? Hash
+    end
+  end
+
+  def clear_feature_data(feature)
+    with_feature(feature) do |f|
+      f.data = {}
+    end
+  end
+
+  def multi_get(*features)
+    return [] if features.empty?
+
+    feature_keys = features.map { |feature| key(feature) }
+    @storage.mget(*feature_keys).map.with_index { |string, index| Feature.new(features[index], string, @options) }
+  end
+
+  def features
+    (@storage.get(features_key) || '').split(',').map(&:to_sym)
+  end
+
+  def feature_states(user = nil)
+    multi_get(*features).each_with_object({}) do |f, hash|
+      hash[f.name] = f.active?(self, user)
+    end
+  end
+
+  def active_features(user = nil)
+    multi_get(*features).select do |f|
+      f.active?(self, user)
+    end.map(&:name)
+  end
+
+  def clear!
+    features.each do |feature|
+      with_feature(feature, &:clear)
+      @storage.del(key(feature))
+    end
+
+    @storage.del(features_key)
+  end
+
+  def exists?(feature)
+    # since redis-rb v4.2, `#exists?` replaces `#exists` which now returns integer value instead of boolean
+    # https://github.com/redis/redis-rb/pull/918
+    if @storage.respond_to?(:exists?)
+      @storage.exists?(key(feature))
+    else
+      @storage.exists(key(feature))
+    end
+  end
+
+  def with_feature(feature)
+    f = get(feature)
+
+    if count_observers > 0
+      before = Marshal.load(Marshal.dump(f))
+      yield(f)
+      save(f)
+      changed
+      notify_observers(:update, before, f)
+    else
+      yield(f)
+      save(f)
+    end
+  end
+
+  private
+
+  def key(name)
+    "feature:#{name}"
+  end
+
+  def features_key
+    'feature:__features__'
+  end
+
+  def save(feature)
+    @storage.set(key(feature.name), feature.serialize)
+    @storage.set(features_key, (features | [feature.name.to_sym]).join(','))
+  end
+end