rollout 2.4.3 → 2.6.1

data/lib/rollout.rb

@@ -1,141 +1,30 @@
-require "rollout/version"
-require "zlib"
-require "set"
-require "json"
+# frozen_string_literal: true
 
-class Rollout
-  RAND_BASE = (2**32 - 1) / 100.0
-  
-  class Feature
-    attr_accessor :groups, :users, :percentage, :data
-    attr_reader :name, :options
-
-    def initialize(name, string = nil, opts = {})
-      @options = opts
-      @name    = name
-
-      if string
-        raw_percentage,raw_users,raw_groups,raw_data = string.split('|', 4)
-        @percentage = raw_percentage.to_f
-        @users = users_from_string(raw_users)
-        @groups = groups_from_string(raw_groups)
-        @data = raw_data.nil? || raw_data.strip.empty? ? {} : JSON.parse(raw_data)
-      else
-        clear
-      end
-    end
-
-    def serialize
-      "#{@percentage}|#{@users.to_a.join(",")}|#{@groups.to_a.join(",")}|#{serialize_data}"
-    end
-
-    def add_user(user)
-      id = user_id(user)
-      @users << id unless @users.include?(id)
-    end
-
-    def remove_user(user)
-      @users.delete(user_id(user))
-    end
-
-    def add_group(group)
-      @groups << group.to_sym unless @groups.include?(group.to_sym)
-    end
-
-    def remove_group(group)
-      @groups.delete(group.to_sym)
-    end
-
-    def clear
-      @groups = groups_from_string("")
-      @users = users_from_string("")
-      @percentage = 0
-      @data = {}
-    end
-
-    def active?(rollout, user)
-      if user
-        id = user_id(user)
-        user_in_percentage?(id) ||
-          user_in_active_users?(id) ||
-            user_in_active_group?(user, rollout)
-      else
-        @percentage == 100
-      end
-    end
-
-    def user_in_active_users?(user)
-      @users.include?(user_id(user))
-    end
-
-    def to_hash
-      {
-        percentage: @percentage,
-        groups: @groups,
-        users: @users
-      }
-    end
-
-    private
-      def user_id(user)
-        if user.is_a?(Integer) || user.is_a?(String)
-          user.to_s
-        else
-          user.send(id_user_by).to_s
-        end
-      end
-
-      def id_user_by
-        @options[:id_user_by] || :id
-      end
-
-      def user_in_percentage?(user)
-        Zlib.crc32(user_id_for_percentage(user)) < RAND_BASE * @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_group?(user, rollout)
-        @groups.any? do |g|
-          rollout.active_in_group?(g, user)
-        end
-      end
-
-      def serialize_data
-        return "" unless @data.is_a? Hash
+require 'rollout/feature'
+require 'rollout/logging'
+require 'rollout/version'
+require 'zlib'
+require 'set'
+require 'json'
+require 'observer'
 
-        @data.to_json
-      end
+class Rollout
+  include Observable
 
-      def users_from_string(raw_users)
-        users = (raw_users || "").split(",").map(&:to_s)
-        if @options[:use_sets]
-          users.to_set
-        else
-          users
-        end
-      end
+  RAND_BASE = (2**32 - 1) / 100.0
 
-      def groups_from_string(raw_groups)
-        groups = (raw_groups || "").split(",").map(&:to_sym)
-        if @options[:use_sets]
-          groups.to_set
-        else
-          groups
-        end
-      end
-  end
+  attr_reader :options, :storage
 
   def initialize(storage, opts = {})
     @storage = storage
     @options = opts
-    @groups  = { all: lambda { |user| true } }
+    @groups  = { all: ->(_user) { true } }
+
+    extend(Logging) if opts[:logging]
+  end
+
+  def groups
+    @groups.keys
   end
 
   def activate(feature)
@@ -145,16 +34,18 @@ class Rollout
   end
 
   def deactivate(feature)
-    with_feature(feature) do |f|
-      f.clear
-    end
+    with_feature(feature, &:clear)
   end
 
   def delete(feature)
-    features = (@storage.get(features_key) || "").split(",")
+    features = (@storage.get(features_key) || '').split(',')
     features.delete(feature.to_s)
-    @storage.set(features_key, features.join(","))
+    @storage.set(features_key, features.join(','))
     @storage.del(key(feature))
+
+    if respond_to?(:logging)
+      logging.delete(feature)
+    end
   end
 
   def set(feature, desired_state)
@@ -193,20 +84,20 @@ class Rollout
 
   def activate_users(feature, users)
     with_feature(feature) do |f|
-      users.each{|user| f.add_user(user)}
+      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)}
+      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)}
+      users.each { |user| f.add_user(user) }
     end
   end
 
@@ -216,7 +107,7 @@ class Rollout
 
   def active?(feature, user = nil)
     feature = get(feature)
-    feature.active?(self, user)
+    feature.active?(user)
   end
 
   def user_in_active_users?(feature, user = nil)
@@ -242,12 +133,12 @@ class Rollout
 
   def active_in_group?(group, user)
     f = @groups[group.to_sym]
-    f && f.call(user)
+    f&.call(user)
   end
 
   def get(feature)
     string = @storage.get(key(feature))
-    Feature.new(feature, string, @options)
+    Feature.new(feature, state: string, rollout: self, options: @options)
   end
 
   def set_feature_data(feature, data)
@@ -263,29 +154,37 @@ class Rollout
   end
 
   def multi_get(*features)
-    feature_keys = features.map{ |feature| key(feature) }
-    @storage.mget(*feature_keys).map.with_index { |string, index| Feature.new(features[index], string, @options) }
+    return [] if features.empty?
+
+    feature_keys = features.map { |feature| key(feature) }
+
+    @storage
+      .mget(*feature_keys)
+      .map
+      .with_index do |string, index|
+        Feature.new(features[index], state: string, rollout: self, options: @options)
+      end
   end
 
   def features
-    (@storage.get(features_key) || "").split(",").map(&:to_sym)
+    (@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)
+    multi_get(*features).each_with_object({}) do |f, hash|
+      hash[f.name] = f.active?(user)
     end
   end
 
   def active_features(user = nil)
-    features.select do |f|
-      active?(f, user)
-    end
+    multi_get(*features).select do |f|
+      f.active?(user)
+    end.map(&:name)
   end
 
   def clear!
     features.each do |feature|
-      with_feature(feature) { |f| f.clear }
+      with_feature(feature, &:clear)
       @storage.del(key(feature))
     end
 
@@ -293,7 +192,28 @@ class Rollout
   end
 
   def exists?(feature)
-    @storage.exists(key(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 = f.deep_clone
+      yield(f)
+      save(f)
+      changed
+      notify_observers(:update, before, f)
+    else
+      yield(f)
+      save(f)
+    end
   end
 
   private
@@ -303,17 +223,11 @@ class Rollout
   end
 
   def features_key
-    "feature:__features__"
-  end
-
-  def with_feature(feature)
-    f = get(feature)
-    yield(f)
-    save(f)
+    'feature:__features__'
   end
 
   def save(feature)
     @storage.set(key(feature.name), feature.serialize)
-    @storage.set(features_key, (features | [feature.name.to_sym]).join(","))
+    @storage.set(features_key, (features | [feature.name.to_sym]).join(','))
   end
 end

data/rollout.gemspec

@@ -1,27 +1,33 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "rollout/version"
+# frozen_string_literal: true
 
-Gem::Specification.new do |s|
-  s.name        = "rollout"
-  s.version     = Rollout::VERSION
-  s.authors     = ["James Golick"]
-  s.email       = ["jamesgolick@gmail.com"]
-  s.description = "Feature flippers with redis."
-  s.summary     = "Feature flippers with redis."
-  s.homepage    = "https://github.com/FetLife/rollout"
-  s.license     = "MIT"
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'rollout/version'
 
-  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"]
+Gem::Specification.new do |spec|
+  spec.name        = 'rollout'
+  spec.version     = Rollout::VERSION
+  spec.authors     = ['James Golick']
+  spec.email       = ['jamesgolick@gmail.com']
+  spec.description = 'Feature flippers with redis.'
+  spec.summary     = 'Feature flippers with redis.'
+  spec.homepage    = 'https://github.com/FetLife/rollout'
+  spec.license     = 'MIT'
 
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "appraisal"
-  s.add_development_dependency "bundler", ">= 1.0.0"
-  s.add_development_dependency "redis"
-  s.add_development_dependency "fakeredis"
-  s.add_development_dependency "simplecov"
-  s.add_development_dependency "codeclimate-test-reporter"
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_dependency 'observer'
+  spec.add_dependency 'redis', '>= 4.0', '< 6'
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'bundler', '>= 1.17'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'rspec_junit_formatter', '~> 0.6'
+  spec.add_development_dependency 'rubocop', '~> 0.71'
+  spec.add_development_dependency 'simplecov', '0.17'
 end

data/spec/rollout/feature_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe "Rollout::Feature" do
+  let(:rollout) { Rollout.new($redis) }
+
+  describe "#add_user" do
+    it "ids a user using id_user_by" do
+      user    = double("User", email: "test@test.com")
+      feature = Rollout::Feature.new(:chat, state: nil, rollout: rollout, options: { id_user_by: :email })
+      feature.add_user(user)
+      expect(user).to have_received :email
+    end
+  end
+
+  describe "#initialize" do
+    describe "when string does not exist" do
+      it 'clears feature attributes when string is not given' do
+        feature = Rollout::Feature.new(:chat, rollout: rollout)
+        expect(feature.groups).to be_empty
+        expect(feature.users).to be_empty
+        expect(feature.percentage).to eq 0
+        expect(feature.data).to eq({})
+      end
+
+      it 'clears feature attributes when string is nil' do
+        feature = Rollout::Feature.new(:chat, state: nil, rollout: rollout)
+        expect(feature.groups).to be_empty
+        expect(feature.users).to be_empty
+        expect(feature.percentage).to eq 0
+        expect(feature.data).to eq({})
+      end
+
+      it 'clears feature attributes when string is empty string' do
+        feature = Rollout::Feature.new(:chat, state: "", rollout: rollout)
+        expect(feature.groups).to be_empty
+        expect(feature.users).to be_empty
+        expect(feature.percentage).to eq 0
+        expect(feature.data).to eq({})
+      end
+
+      describe "when there is no data" do
+        it 'sets @data to empty hash' do
+          feature = Rollout::Feature.new(:chat, state: "0||", rollout: rollout)
+          expect(feature.data).to eq({})
+        end
+
+        it 'sets @data to empty hash' do
+          feature = Rollout::Feature.new(:chat, state: "|||   ", rollout: rollout)
+          expect(feature.data).to eq({})
+        end
+      end
+    end
+  end
+end

data/spec/rollout/logging_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+RSpec.describe 'Rollout::Logging' do
+  let(:rollout) { Rollout.new($redis, logging: logging) }
+  let(:logging) { true }
+  let(:feature) { :foo }
+
+  it 'logs changes' do
+    expect(rollout.logging.last_event(feature)).to be_nil
+
+    rollout.activate_percentage(feature, 50)
+
+    expect(rollout.logging.updated_at(feature)).to_not be_nil
+
+    first_event = rollout.logging.last_event(feature)
+
+    expect(first_event.name).to eq 'update'
+    expect(first_event.data).to eq(before: { percentage: 0 }, after: { percentage: 50 })
+
+    rollout.activate_percentage(feature, 75)
+
+    second_event = rollout.logging.last_event(feature)
+
+    expect(second_event.name).to eq 'update'
+    expect(second_event.data).to eq(before: { percentage: 50 }, after: { percentage: 75 })
+
+    rollout.activate_group(feature, :hipsters)
+
+    third_event = rollout.logging.last_event(feature)
+
+    expect(third_event.name).to eq 'update'
+    expect(third_event.data).to eq(before: { groups: [] }, after: { groups: ['hipsters'] })
+
+    expect(rollout.logging.events(feature)).to eq [first_event, second_event, third_event]
+  end
+
+  context 'logging data changes' do
+    it 'logs changes' do
+      expect(rollout.logging.last_event(feature)).to be_nil
+
+      rollout.set_feature_data(feature, description: "foo")
+
+      event = rollout.logging.last_event(feature)
+
+      expect(event).not_to be_nil
+      expect(event.name).to eq 'update'
+      expect(event.data).to eq(before: { "data.description": nil }, after: { "data.description": "foo" })
+    end
+  end
+
+  context 'no logging' do
+    let(:logging) { nil }
+
+    it 'doesnt even respond to logging' do
+      expect(rollout).not_to respond_to :logging
+    end
+  end
+
+  context 'history truncation' do
+    let(:logging) { { history_length: 1 } }
+
+    it 'logs changes' do
+      expect(rollout.logging.last_event(feature)).to be_nil
+
+      rollout.activate_percentage(feature, 25)
+
+      first_event = rollout.logging.last_event(feature)
+
+      expect(first_event.name).to eq 'update'
+      expect(first_event.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+
+      rollout.activate_percentage(feature, 30)
+
+      second_event = rollout.logging.last_event(feature)
+
+      expect(second_event.name).to eq 'update'
+      expect(second_event.data).to eq(before: { percentage: 25 }, after: { percentage: 30 })
+
+      expect(rollout.logging.events(feature)).to eq [second_event]
+    end
+  end
+
+  context 'with context' do
+    let(:current_user) { double(nickname: 'lester') }
+
+    it 'adds context to the event' do
+      rollout.logging.with_context(actor: current_user.nickname) do
+        rollout.activate_percentage(feature, 25)
+      end
+
+      event = rollout.logging.last_event(feature)
+
+      expect(event.name).to eq 'update'
+      expect(event.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+      expect(event.context).to eq(actor: current_user.nickname)
+    end
+  end
+
+  context 'global logs' do
+    let(:logging) { { global: true } }
+    let(:feature_foo) { 'foo' }
+    let(:feature_bar) { 'bar' }
+
+    it 'logs changes' do
+      expect(rollout.logging.last_event(feature_foo)).to be_nil
+
+      rollout.activate_percentage(feature_foo, 25)
+
+      event_foo = rollout.logging.last_event(feature_foo)
+
+      expect(event_foo.feature).to eq feature_foo
+      expect(event_foo.name).to eq 'update'
+      expect(event_foo.data).to eq(before: { percentage: 0 }, after: { percentage: 25 })
+
+      expect(rollout.logging.events(feature_foo)).to eq [event_foo]
+
+      rollout.activate_percentage(feature_bar, 30)
+
+      event_bar = rollout.logging.last_event(feature_bar)
+
+      expect(event_bar.feature).to eq feature_bar
+      expect(event_bar.name).to eq 'update'
+      expect(event_bar.data).to eq(before: { percentage: 0 }, after: { percentage: 30 })
+
+      expect(rollout.logging.events(feature_bar)).to eq [event_bar]
+
+      expect(rollout.logging.global_events).to eq [event_foo, event_bar]
+    end
+  end
+
+  context 'no logging for block' do
+    it 'doesnt log' do
+      rollout.logging.without do
+        rollout.activate_percentage(feature, 25)
+      end
+
+      event = rollout.logging.last_event(feature)
+
+      expect(event).to be_nil
+    end
+  end
+end
+