rollout 2.1.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc88ca14f2eb1ae5156873fce8e5f569e8e551d5
-  data.tar.gz: 37e6306414e96c1dad888d68f4241bb339af5dd0
+  metadata.gz: c64885c4cf5254332da642dc02ee9b21aeaa62c8
+  data.tar.gz: 7847a0a450a0641f71b1f47926ce867dc00e40af
 SHA512:
-  metadata.gz: 43b4ba29fd8bc735ec1646aa3386ebf409d7d19c3d459fdd649670cf773bcef5ed28583b653ad824b15dcb022ed0e49d55b256a1c477044d93fbd292451df88f
-  data.tar.gz: 36031f802e6b61f2d4e8d5205da8bcc8103cc837ddf6fcff1b51db3c4f71e6a2deeb18286e691fdc5f2daa9ab82ee7717118739cd22d7b6bcd5f72de4075e0e4
+  metadata.gz: 8d673450a953468fbe6ebca47ee985af3499a37627dd1e086f5b018216d6bc2d3c12ffac1a33e2bbc369802d059faff2a69ef8f5899f7a7e10b6750a852ffad3
+  data.tar.gz: 594d9322387a7019ca0f0d34cf8d5c4133181ec960f7dd8749babc1353d978bd326505651f220dd3cf034b46113c7054a7c216f142605001cad43f0938860ffa

data/.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
+sudo: false
 services:
   - redis-server
 rvm:
+  - 2.2
   - 2.1
   - 2.0.0
   - 1.9.3

data/Gemfile.lock

@@ -1,40 +1,52 @@
 PATH
   remote: .
   specs:
-    rollout (2.0.0)
+    rollout (2.2.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    bourne (1.0)
-      mocha (= 0.9.8)
-    diff-lcs (1.1.3)
-    git (1.2.5)
+    codeclimate-test-reporter (0.4.8)
+      simplecov (>= 0.7.1, < 1.0.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    git (1.2.9.1)
     jeweler (1.6.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    mocha (0.9.8)
-      rake
-    rake (0.9.2.2)
-    redis (3.0.7)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.1)
-    rspec-expectations (2.10.0)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.1)
+    json (1.8.3)
+    rake (10.4.2)
+    redis (3.2.1)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.2)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    simplecov (0.11.1)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bourne (= 1.0)
   bundler (>= 1.0.0)
+  codeclimate-test-reporter
   jeweler (~> 1.6.4)
-  mocha (= 0.9.8)
   redis
   rollout!
-  rspec (~> 2.10.0)
+  rspec
+
+BUNDLED WITH
+   1.10.6

data/README.md

@@ -0,0 +1,186 @@
+# rollout
+
+Feature flippers.
+
+[![Build Status](https://travis-ci.org/FetLife/rollout.svg?branch=master)](https://travis-ci.org/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))
+
+## MAKE SURE TO READ THIS: 2.X Changes and Migration Path
+
+As of rollout-2.x, only one key is used per feature for performance reasons.
+The data format is `percentage|user_id,user_id,...|group,_group...`. This has
+the effect of making concurrent feature modifications unsafe, but in practice,
+I doubt this will actually be a problem.
+
+This also has the effect of rollout no longer being dependent on redis. Just
+give it something that responds to `set(key,value)`, `get(key)` and
+`del(key)`.
+
+If you have been using the 1.x format, you can initialize Rollout with
+`migrate: true` and it'll do its best to automatically migrate your old
+features to the new format. There will be some performance impact, but it
+should be limited and short-lived since each feature only needs to get
+migrated once.
+
+## Rollout::Legacy
+
+If you'd prefer to continue to use the old layout in redis, `Rollout::Legacy`
+is a copy and paste of the old code :-).
+
+## 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)
+```
+
+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)
+```
+
+## 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) % 100 < 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.
+
+## Feature is broken
+
+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 http://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.
+
+## Implementations in other languages
+
+*   Python: http://github.com/asenchi/proclaim
+*   PHP: https://github.com/opensoft/rollout
+*   Clojure: https://github.com/tcrayford/shoutout
+
+
+## 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/lib/rollout/version.rb

@@ -1,3 +1,3 @@
 class Rollout
-  VERSION = "2.1.0"
+  VERSION = "2.2.1"
 end

data/lib/rollout.rb

@@ -1,6 +1,7 @@
 require "rollout/version"
 require "rollout/legacy"
 require "zlib"
+require "set"
 
 class Rollout
   class Feature
@@ -14,15 +15,15 @@ class Rollout
       if string
         raw_percentage,raw_users,raw_groups = string.split("|")
         @percentage = raw_percentage.to_i
-        @users = (raw_users || "").split(",").map(&:to_s)
-        @groups = (raw_groups || "").split(",").map(&:to_sym)
+        @users = (raw_users || "").split(",").map(&:to_s).to_set
+        @groups = (raw_groups || "").split(",").map(&:to_sym).to_set
       else
         clear
       end
     end
 
     def serialize
-      "#{@percentage}|#{@users.join(",")}|#{@groups.join(",")}"
+      "#{@percentage}|#{@users.to_a.join(",")}|#{@groups.to_a.join(",")}"
     end
 
     def add_user(user)
@@ -43,8 +44,8 @@ class Rollout
     end
 
     def clear
-      @groups = []
-      @users = []
+      @groups = Set.new
+      @users = Set.new
       @percentage = 0
     end
 
@@ -60,15 +61,16 @@ class Rollout
     end
 
     def to_hash
-      {:percentage => @percentage,
-       :groups     => @groups,
-       :users      => @users}
+      {
+        percentage: @percentage,
+        groups: @groups,
+        users: @users
+      }
     end
 
     private
       def user_id(user)
-        if user.is_a?(Fixnum) ||
-             user.is_a?(String)
+        if user.is_a?(Fixnum) || user.is_a?(String)
           user.to_s
         else
           user.send(id_user_by).to_s
@@ -80,7 +82,15 @@ class Rollout
       end
 
       def user_in_percentage?(user)
-        Zlib.crc32(user_id(user)) % 100 < @percentage
+        Zlib.crc32(user_id_for_percentage(user)) % 100 < @percentage
+      end
+
+      def user_id_for_percentage(user)
+        if @options[:randomize_percentage]
+          user_id(user).to_s + @name.to_s
+        else
+          user_id(user)
+        end
       end
 
       def user_in_active_users?(user)
@@ -97,7 +107,7 @@ class Rollout
   def initialize(storage, opts = {})
     @storage = storage
     @options = opts
-    @groups  = {:all => lambda { |user| true }}
+    @groups  = { all: lambda { |user| true } }
     @legacy  = Legacy.new(opts[:legacy_storage] || @storage) if opts[:migrate]
   end
 
@@ -113,6 +123,13 @@ class Rollout
     end
   end
 
+  def delete(feature)
+    features = (@storage.get(features_key) || "").split(",").map(&:to_sym)
+    features.delete(feature)
+    @storage.set(features_key, features.join(","))
+    @storage.del(key(feature))
+  end
+
   def set(feature, desired_state)
     with_feature(feature) do |f|
       if desired_state
@@ -147,6 +164,18 @@ class Rollout
     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 define_group(group, &block)
     @groups[group.to_sym] = block
   end
@@ -156,6 +185,10 @@ class Rollout
     feature.active?(self, user)
   end
 
+  def inactive?(feature, user = nil)
+    !active(feature, user)
+  end
+
   def activate_percentage(feature, percentage)
     with_feature(feature) do |f|
       f.percentage = percentage
@@ -193,6 +226,18 @@ class Rollout
     (@storage.get(features_key) || "").split(",").map(&:to_sym)
   end
 
+  def feature_states(user = nil)
+    features.each_with_object({}) do |f, hash|
+      hash[f] = active?(f, user)
+    end
+  end
+
+  def active_features(user = nil)
+    features.select do |f|
+      active?(f, user)
+    end
+  end
+
   def clear!
     features.each do |feature|
       with_feature(feature) { |f| f.clear }

data/rollout.gemspec

@@ -11,17 +11,14 @@ Gem::Specification.new do |s|
   s.summary = "Feature flippers with redis."
   s.homepage = "https://github.com/jamesgolick/rollout"
 
-  s.rubyforge_project = "rollout"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "rspec", "~> 2.10.0"
+  s.add_development_dependency "rspec"
   s.add_development_dependency "bundler", ">= 1.0.0"
   s.add_development_dependency "jeweler", "~> 1.6.4"
-  s.add_development_dependency "bourne", "1.0"
-  s.add_development_dependency "mocha", "0.9.8"
   s.add_development_dependency "redis"
+  s.add_development_dependency "codeclimate-test-reporter"
 end

data/spec/legacy_spec.rb

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require "spec_helper"
 
-describe "Rollout::Legacy" do
+RSpec.describe "Rollout::Legacy" do
   before do
     @redis   = Redis.new
     @rollout = Rollout::Legacy.new(@redis)
@@ -13,16 +13,16 @@ describe "Rollout::Legacy" do
     end
 
     it "the feature is active for users for which the block evaluates to true" do
-      @rollout.should be_active(:chat, stub(:id => 5))
+      expect(@rollout).to be_active(:chat, double(id: 5))
     end
 
     it "is not active for users for which the block evaluates to false" do
-      @rollout.should_not be_active(:chat, stub(:id => 1))
+      expect(@rollout).not_to be_active(:chat, double(id: 1))
     end
 
     it "is not active if a group is found in Redis but not defined in Rollout" do
       @rollout.activate_group(:chat, :fake)
-      @rollout.should_not be_active(:chat, stub(:id => 1))
+      expect(@rollout).not_to be_active(:chat, double(id: 1))
     end
   end
 
@@ -32,7 +32,7 @@ describe "Rollout::Legacy" do
     end
 
     it "evaluates to true no matter what" do
-      @rollout.should be_active(:chat, stub(:id => 0))
+      expect(@rollout).to be_active(:chat, double(id: 0))
     end
   end
 
@@ -45,11 +45,11 @@ describe "Rollout::Legacy" do
     end
 
     it "deactivates the rules for that group" do
-      @rollout.should_not be_active(:chat, stub(:id => 10))
+      expect(@rollout).not_to be_active(:chat, double(id: 10))
     end
 
     it "leaves the other groups active" do
-      @rollout.should be_active(:chat, stub(:id => 5))
+      expect(@rollout).to be_active(:chat, double(id: 5))
     end
   end
 
@@ -58,56 +58,56 @@ describe "Rollout::Legacy" do
       @rollout.define_group(:fivesonly) { |user| user.id == 5 }
       @rollout.activate_group(:chat, :all)
       @rollout.activate_group(:chat, :fivesonly)
-      @rollout.activate_user(:chat, stub(:id => 51))
+      @rollout.activate_user(:chat, double(id: 51))
       @rollout.activate_percentage(:chat, 100)
       @rollout.activate_globally(:chat)
       @rollout.deactivate_all(:chat)
     end
 
     it "removes all of the groups" do
-      @rollout.should_not be_active(:chat, stub(:id => 0))
+      expect(@rollout).not_to be_active(:chat, double(id: 0))
     end
 
     it "removes all of the users" do
-      @rollout.should_not be_active(:chat, stub(:id => 51))
+      expect(@rollout).not_to be_active(:chat, double(id: 51))
     end
 
     it "removes the percentage" do
-      @rollout.should_not be_active(:chat, stub(:id => 24))
+      expect(@rollout).not_to be_active(:chat, double(id: 24))
     end
 
     it "removes globally" do
-      @rollout.should_not be_active(:chat)
+      expect(@rollout).not_to be_active(:chat)
     end
   end
 
   describe "activating a specific user" do
     before do
-      @rollout.activate_user(:chat, stub(:id => 42))
+      @rollout.activate_user(:chat, double(id: 42))
     end
 
     it "is active for that user" do
-      @rollout.should be_active(:chat, stub(:id => 42))
+      expect(@rollout).to be_active(:chat, double(id: 42))
     end
 
     it "remains inactive for other users" do
-      @rollout.should_not be_active(:chat, stub(:id => 24))
+      expect(@rollout).not_to be_active(:chat, double(id: 24))
     end
   end
 
   describe "deactivating a specific user" do
     before do
-      @rollout.activate_user(:chat, stub(:id => 42))
-      @rollout.activate_user(:chat, stub(:id => 24))
-      @rollout.deactivate_user(:chat, stub(:id => 42))
+      @rollout.activate_user(:chat, double(id: 42))
+      @rollout.activate_user(:chat, double(id: 24))
+      @rollout.deactivate_user(:chat, double(id: 42))
     end
 
     it "that user should no longer be active" do
-      @rollout.should_not be_active(:chat, stub(:id => 42))
+      expect(@rollout).not_to be_active(:chat, double(id: 42))
     end
 
     it "remains active for other active users" do
-      @rollout.should be_active(:chat, stub(:id => 24))
+      expect(@rollout).to be_active(:chat, double(id: 24))
     end
   end
 
@@ -117,7 +117,7 @@ describe "Rollout::Legacy" do
     end
 
     it "activates the feature" do
-      @rollout.should be_active(:chat)
+      expect(@rollout).to be_active(:chat)
     end
   end
 
@@ -127,7 +127,7 @@ describe "Rollout::Legacy" do
     end
 
     it "activates the feature for that percentage of the users" do
-      (1..120).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should == 39
+      expect((1..120).select { |id| @rollout.active?(:chat, double(id: id)) }.length).to eq(39)
     end
   end
 
@@ -137,7 +137,7 @@ describe "Rollout::Legacy" do
     end
 
     it "activates the feature for that percentage of the users" do
-      (1..200).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should == 40
+      expect((1..200).select { |id| @rollout.active?(:chat, double(id: id)) }.length).to eq(40)
     end
   end
 
@@ -147,7 +147,7 @@ describe "Rollout::Legacy" do
     end
 
     it "activates the feature for that percentage of the users" do
-      (1..100).select { |id| @rollout.active?(:chat, stub(:id => id)) }.length.should == 5
+      expect((1..100).select { |id| @rollout.active?(:chat, double(id: id)) }.length).to eq(5)
     end
   end
 
@@ -159,7 +159,7 @@ describe "Rollout::Legacy" do
     end
 
     it "becomes inactivate for all users" do
-      @rollout.should_not be_active(:chat, stub(:id => 24))
+      expect(@rollout).not_to be_active(:chat, double(id: 24))
     end
   end
 
@@ -170,7 +170,7 @@ describe "Rollout::Legacy" do
     end
 
     it "becomes inactivate" do
-      @rollout.should_not be_active(:chat)
+      expect(@rollout).not_to be_active(:chat)
     end
   end
 
@@ -185,7 +185,7 @@ describe "Rollout::Legacy" do
       end
 
       it "returns all global features" do
-        @rollout.info[:global].should include(*features)
+        expect(@rollout.info[:global]).to include(*features)
       end
     end
 
@@ -195,26 +195,26 @@ describe "Rollout::Legacy" do
         @rollout.activate_group(:chat, :caretakers)
         @rollout.activate_group(:chat, :greeters)
         @rollout.activate_globally(:signup)
-        @rollout.activate_user(:chat, stub(:id => 42))
+        @rollout.activate_user(:chat, double(id: 42))
       end
 
       it "returns info about all the activations" do
         info = @rollout.info(:chat)
-        info[:percentage].should == 10
-        info[:groups].should include(:caretakers, :greeters)
-        info[:users].should include(42)
-        info[:global].should include(:signup)
+        expect(info[:percentage]).to eq(10)
+        expect(info[:groups]).to include(:caretakers, :greeters)
+        expect(info[:users]).to include(42)
+        expect(info[:global]).to include(:signup)
       end
     end
 
     describe "without a percentage set" do
       it "defaults to 0" do
-        @rollout.info(:chat).should == {
-          :percentage => 0,
-          :groups     => [],
-          :users      => [],
-          :global     => []
-        }
+        expect(@rollout.info(:chat)).to eq(
+          percentage: 0,
+          groups: [],
+          users: [],
+          global: [],
+        )
       end
     end
   end