rollout 2.6.2 → 3.2.0

data/lib/rollout/feature.rb

@@ -1,28 +1,27 @@
 # frozen_string_literal: true
 
+require 'rollout/feature_state'
+
 class Rollout
   class Feature
     attr_accessor :groups, :users, :percentage, :data
     attr_reader :name, :options
 
-    def initialize(name, rollout:, state: nil, options: {})
-      @name = name
+    def initialize(state:, rollout:, options: {}, name: nil)
       @rollout = rollout
       @options = options
-
-      if state
-        raw_percentage, raw_users, raw_groups, raw_data = state.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
+      @name = name.nil? ? state.name.to_sym : name
+      assign_state(state)
     end
 
-    def serialize
-      "#{@percentage}|#{@users.to_a.join(',')}|#{@groups.to_a.join(',')}|#{serialize_data}"
+    def to_feature_state
+      FeatureState.new(
+        name: @name,
+        percentage: @percentage,
+        users: Array(@users),
+        groups: Array(@groups),
+        data: @data,
+      )
     end
 
     def add_user(user)
@@ -43,10 +42,7 @@ class Rollout
     end
 
     def clear
-      @groups = groups_from_string('')
-      @users = users_from_string('')
-      @percentage = 0
-      @data = {}
+      assign_state(FeatureState.new(name: @name, percentage: 0))
     end
 
     def active?(user)
@@ -77,12 +73,21 @@ class Rollout
       c = self.clone
       c.instance_variable_set('@rollout', nil)
       c = Marshal.load(Marshal.dump(c))
-      c.instance_variable_set('@rollot', @rollout)
+      c.instance_variable_set('@rollout', @rollout)
       c
     end
 
     private
 
+    def assign_state(state)
+      state = state.deep_clone
+
+      @percentage = state.percentage
+      @users = users_from_array(state.users)
+      @groups = groups_from_array(state.groups)
+      @data = state.data
+    end
+
     def user_id(user)
       if user.is_a?(Integer) || user.is_a?(String)
         user.to_s
@@ -113,14 +118,8 @@ class Rollout
       end
     end
 
-    def serialize_data
-      return '' unless @data.is_a? Hash
-
-      @data.to_json
-    end
-
-    def users_from_string(raw_users)
-      users = (raw_users || '').split(',').map(&:to_s)
+    def users_from_array(users)
+      users = Array(users).map(&:to_s)
       if @options[:use_sets]
         users.to_set
       else
@@ -128,8 +127,8 @@ class Rollout
       end
     end
 
-    def groups_from_string(raw_groups)
-      groups = (raw_groups || '').split(',').map(&:to_sym)
+    def groups_from_array(groups)
+      groups = Array(groups).map(&:to_sym)
       if @options[:use_sets]
         groups.to_set
       else

data/lib/rollout/feature_state.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class Rollout
+  class FeatureState
+    attr_reader :name, :percentage, :users, :groups, :data
+
+    def initialize(name:, percentage:, users: [], groups: [], data: {})
+      raise ArgumentError, "data must be a Hash" unless data.is_a?(Hash)
+
+      @name = name.to_s.dup
+      @percentage = percentage.to_f
+      @users = Array(users).map { |user| user.to_s.dup }
+      @groups = Array(groups).map { |group| group.to_s.dup }
+      @data = canonicalize_data(data)
+    end
+
+    def ==(other)
+      other.is_a?(FeatureState) &&
+        name == other.name &&
+        percentage == other.percentage &&
+        users == other.users &&
+        groups == other.groups &&
+        data == other.data
+    end
+
+    def deep_clone
+      self.class.new(
+        name: name,
+        percentage: percentage,
+        users: users,
+        groups: groups,
+        data: data,
+      )
+    end
+
+    private
+
+    def canonicalize_data(data)
+      JSON.parse(data.to_json)
+    end
+  end
+end

data/lib/rollout/logging.rb

@@ -1,13 +1,12 @@
+# frozen_string_literal: true
+
 class Rollout
   module Logging
     def self.extended(rollout)
       options = rollout.options[:logging]
       options = options.is_a?(Hash) ? options.dup : {}
-      options[:storage] ||= rollout.storage
-
-      logger = Logger.new(**options)
 
-      rollout.add_observer(logger, :log)
+      logger = Logger.new(adapter: rollout.adapter, **options)
       rollout.define_singleton_method(:logging) do
         logger
       end
@@ -16,12 +15,6 @@ class Rollout
     class Event
       attr_reader :feature, :name, :data, :context, :created_at
 
-      def self.from_raw(value, score)
-        hash = JSON.parse(value, symbolize_names: true)
-
-        new(**hash.merge(created_at: Time.at(-score.to_f / 1_000_000)))
-      end
-
       def initialize(feature: nil, name:, data:, context: {}, created_at:)
         @feature = feature
         @name = name
@@ -53,45 +46,49 @@ class Rollout
     end
 
     class Logger
-      def initialize(storage: nil, history_length: 50, global: false)
+      attr_reader :history_length, :global, :adapter
+
+      def initialize(adapter:, history_length: 50, global: false)
+        @adapter = adapter
         @history_length = history_length
-        @storage = storage
         @global = global
       end
 
       def updated_at(feature_name)
-        storage_key = events_storage_key(feature_name)
-        _, score = @storage.zrange(storage_key, 0, 0, with_scores: true).first
-        Time.at(-score.to_f / 1_000_000) if score
+        @adapter.feature_updated_at(feature_name)
       end
 
       def last_event(feature_name)
-        storage_key = events_storage_key(feature_name)
-        value = @storage.zrange(storage_key, 0, 0, with_scores: true).first
-        Event.from_raw(*value) if value
+        events(feature_name, limit: 1).last
       end
 
-      def events(feature_name)
-        storage_key = events_storage_key(feature_name)
-        @storage
-          .zrange(storage_key, 0, -1, with_scores: true)
-          .map { |v| Event.from_raw(*v) }
-          .reverse
+      def events(feature_name, limit: nil)
+        @adapter.feature_events(feature_name, limit: limit)
       end
 
-      def global_events
-        @storage
-          .zrange(global_events_storage_key, 0, -1, with_scores: true)
-          .map { |v| Event.from_raw(*v) }
-          .reverse
+      def global_events(limit: nil)
+        @adapter.global_events(limit: limit)
       end
 
       def delete(feature_name)
-        storage_key = events_storage_key(feature_name)
-        @storage.del(storage_key)
+        @adapter.delete_feature_events(feature_name)
       end
 
-      def update(before, after)
+      def delete_event_for(feature_name)
+        return unless logging_enabled? && global
+
+        Event.new(
+          feature: feature_name.to_s,
+          name: :delete,
+          data: {},
+          context: current_context,
+          created_at: Time.now,
+        )
+      end
+
+      def event_for(before, after)
+        return unless logging_enabled?
+
         before_hash = before.to_hash
         before_hash.delete(:data).each do |k, v|
           before_hash["data.#{k}"] = v
@@ -116,41 +113,13 @@ class Rollout
 
         return if changed_count == 0
 
-        event = Event.new(
+        Event.new(
           feature: after.name,
           name: :update,
           data: change,
           context: current_context,
           created_at: Time.now,
         )
-
-        storage_key = events_storage_key(after.name)
-
-        @storage.zadd(storage_key, -event.timestamp, event.serialize)
-        @storage.zremrangebyrank(storage_key, @history_length, -1)
-
-        if @global
-          @storage.zadd(global_events_storage_key, -event.timestamp, event.serialize)
-          @storage.zremrangebyrank(global_events_storage_key, @history_length, -1)
-        end
-      end
-
-      def log(event, *args)
-        return unless logging_enabled?
-
-        unless respond_to?(event)
-          raise ArgumentError, "Invalid log event: #{event}"
-        end
-
-        expected_arity = method(event).arity
-        unless args.count == expected_arity
-          raise(
-            ArgumentError,
-            "Invalid number of arguments for event '#{event}': expected #{expected_arity} but got #{args.count}",
-          )
-        end
-
-        public_send(event, *args)
       end
 
       CONTEXT_THREAD_KEY = :rollout_logging_context
@@ -171,29 +140,16 @@ class Rollout
       end
 
       def without
+        previous = Thread.current[WITHOUT_THREAD_KEY]
         Thread.current[WITHOUT_THREAD_KEY] = true
         yield
       ensure
-        Thread.current[WITHOUT_THREAD_KEY] = nil
+        Thread.current[WITHOUT_THREAD_KEY] = previous
       end
 
       def logging_enabled?
         !Thread.current[WITHOUT_THREAD_KEY]
       end
-
-      private
-
-      def global_events_storage_key
-        "feature:_global_:logging:events"
-      end
-
-      def events_storage_key(feature_name)
-        "feature:#{feature_name}:logging:events"
-      end
-
-      def current_timestamp
-        (Time.now.to_f * 1_000_000).to_i
-      end
     end
   end
 end

data/lib/rollout/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Rollout
-  VERSION = '2.6.2'
+  VERSION = '3.2.0'
 end

data/lib/rollout.rb

@@ -13,14 +13,14 @@ class Rollout
 
   RAND_BASE = (2**32 - 1) / 100.0
 
-  attr_reader :options, :storage
+  attr_reader :options, :adapter
 
-  def initialize(storage, opts = {})
-    @storage = storage
-    @options = opts
+  def initialize(adapter:, **options)
+    @adapter = adapter
+    @options = options
     @groups  = { all: ->(_user) { true } }
 
-    extend(Logging) if opts[:logging]
+    extend(Logging) if options[:logging]
   end
 
   def groups
@@ -38,12 +38,16 @@ class Rollout
   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)
+    return @adapter.delete_feature(feature) unless respond_to?(:logging)
+
+    if @adapter.respond_to?(:delete_feature_with_history)
+      @adapter.delete_feature_with_history(
+        feature,
+        event: logging.delete_event_for(feature),
+        history_length: logging.history_length,
+      )
+    else
+      @adapter.delete_feature(feature)
       logging.delete(feature)
     end
   end
@@ -137,8 +141,12 @@ class Rollout
   end
 
   def get(feature)
-    string = @storage.get(key(feature))
-    Feature.new(feature, state: string, rollout: self, options: @options)
+    Feature.new(
+      state: @adapter.fetch_feature(feature),
+      rollout: self,
+      options: @options,
+      name: feature,
+    )
   end
 
   def set_feature_data(feature, data)
@@ -156,18 +164,13 @@ class Rollout
   def multi_get(*features)
     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
+    @adapter.fetch_features(features).zip(features).map do |state, name|
+      Feature.new(state: state, rollout: self, options: @options, name: name)
+    end
   end
 
   def features
-    (@storage.get(features_key) || '').split(',').map(&:to_sym)
+    @adapter.feature_names.map(&:to_sym)
   end
 
   def feature_states(user = nil)
@@ -185,49 +188,59 @@ class Rollout
   def clear!
     features.each do |feature|
       with_feature(feature, &:clear)
-      @storage.del(key(feature))
+      @adapter.delete_feature(feature)
     end
-
-    @storage.del(features_key)
+    @adapter.clear_features
   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
+    @adapter.feature_exists?(feature)
   end
 
   def with_feature(feature)
-    f = get(feature)
+    mutated = nil
+    before = nil
+    capture_logging = logging_capture?
+    notify = count_observers > 0
+    snapshot = notify || capture_logging
+
+    @adapter.mutate_feature(feature) do |current_state|
+      mutated = Feature.new(
+        state: current_state,
+        rollout: self,
+        options: @options,
+        name: feature,
+      )
+      before = mutated.deep_clone if snapshot
+      yield mutated
+
+      state = mutated.to_feature_state
+      mutated = Feature.new(
+        state: state,
+        rollout: self,
+        options: @options,
+        name: feature,
+      )
+      event = capture_logging ? logging.event_for(before, mutated) : nil
+      result = { state: state, event: event }
+      if event
+        result[:history_length] = logging.history_length
+        result[:global] = logging.global
+      end
+      result
+    end
 
-    if count_observers > 0
-      before = f.deep_clone
-      yield(f)
-      save(f)
+    if notify
       changed
-      notify_observers(:update, before, f)
-    else
-      yield(f)
-      save(f)
+      notify_observers(:update, before, mutated)
     end
-  end
 
-  private
-
-  def key(name)
-    "feature:#{name}"
+    mutated
   end
 
-  def features_key
-    'feature:__features__'
-  end
+  private
 
-  def save(feature)
-    @storage.set(key(feature.name), feature.serialize)
-    @storage.set(features_key, (features | [feature.name.to_sym]).join(','))
+  def logging_capture?
+    respond_to?(:logging) && logging.logging_enabled?
   end
 end

data/rollout.gemspec

@@ -8,12 +8,14 @@ Gem::Specification.new do |spec|
   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.description = 'Feature flippers.'
+  spec.summary     = 'Feature flippers.'
   spec.homepage    = 'https://github.com/FetLife/rollout'
   spec.license     = 'MIT'
 
-  spec.files         = `git ls-files`.split("\n")
+  spec.files = `git ls-files`.split("\n").reject do |file|
+    file.start_with?('rollout-redis-adapter/', 'rollout-active_record-adapter/')
+  end
   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']
@@ -21,10 +23,9 @@ Gem::Specification.new do |spec|
   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 'bundler', '>= 2.1'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rspec', '~> 3.13'
   spec.add_development_dependency 'rspec_junit_formatter', '~> 0.6'

data/spec/rollout/feature_spec.rb

@@ -1,54 +1,85 @@
 require "spec_helper"
 
 describe "Rollout::Feature" do
-  let(:rollout) { Rollout.new($redis) }
+  def build_feature(name: :chat, percentage: 0, users: [], groups: [], data: {}, options: {}, rollout: nil)
+    rollout ||= Object.new
+    Rollout::Feature.new(
+      state: Rollout::FeatureState.new(
+        name: name,
+        percentage: percentage,
+        users: users,
+        groups: groups,
+        data: data,
+      ),
+      rollout: rollout,
+      options: options,
+    )
+  end
 
   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 })
+      user = double("User", email: "test@test.com")
+      feature = build_feature(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
+    it "uses the state's name" do
+      expect(build_feature(name: :video).name).to eq :video
     end
+
+    it "preserves an explicit public name" do
+      feature = Rollout::Feature.new(
+        state: Rollout::FeatureState.new(name: :chat, percentage: 0),
+        rollout: Object.new,
+        name: "chat",
+      )
+      feature.percentage = 50
+      feature.clear
+
+      expect(feature.name).to eq "chat"
+      expect(feature.to_feature_state.name).to eq "chat"
+    end
+
+    it "clears feature attributes for an empty state" do
+      feature = build_feature
+
+      expect(feature.groups).to be_empty
+      expect(feature.users).to be_empty
+      expect(feature.percentage).to eq 0
+      expect(feature.data).to eq({})
+    end
+  end
+
+  describe "percentage assignment" do
+    it "keeps the same users across features when randomize_percentage is off" do
+      chat = build_feature(name: :chat, percentage: 20)
+      beta = build_feature(name: :beta, percentage: 20)
+
+      expect(chat.active?(double(id: 2))).to eq true
+      expect(chat.active?(double(id: 6))).to eq true
+      expect(chat.active?(double(id: 1))).to eq false
+      expect(beta.active?(double(id: 2))).to eq true
+      expect(beta.active?(double(id: 1))).to eq false
+    end
+
+    it "changes assignment by feature name when randomize_percentage is on" do
+      chat = build_feature(name: :chat, percentage: 20, options: { randomize_percentage: true })
+      beta = build_feature(name: :beta, percentage: 20, options: { randomize_percentage: true })
+
+      expect(chat.active?(double(id: 1))).to eq true
+      expect(beta.active?(double(id: 1))).to eq false
+      expect(chat.active?(double(id: 5))).to eq false
+      expect(beta.active?(double(id: 5))).to eq true
+    end
+  end
+
+  it "does not expose assign_state" do
+    feature = build_feature
+
+    expect(feature).not_to respond_to(:assign_state)
+    expect(feature.private_methods).to include(:assign_state)
   end
 end