split 3.4.0 → 4.0.1

data/lib/split/experiment.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'rubystats'
+
 module Split
   class Experiment
     attr_accessor :name
@@ -13,26 +16,19 @@ module Split
       :resettable => true
     }
 
+    def self.find(name)
+      Split.cache(:experiments, name) do
+        return unless Split.redis.exists?(name)
+        Experiment.new(name).tap { |exp| exp.load_from_redis }
+      end
+    end
+
     def initialize(name, options = {})
       options = DEFAULT_OPTIONS.merge(options)
 
       @name = name.to_s
 
-      alternatives = extract_alternatives_from_options(options)
-
-      if alternatives.empty? && (exp_config = Split.configuration.experiment_for(name))
-        options = {
-          alternatives: load_alternatives_from_configuration,
-          goals: Split::GoalsCollection.new(@name).load_from_configuration,
-          metadata: load_metadata_from_configuration,
-          resettable: exp_config.fetch(:resettable, true),
-          algorithm: exp_config[:algorithm]
-        }
-      else
-        options[:alternatives] = alternatives
-      end
-
-      set_alternatives_and_options(options)
+      extract_alternatives_from_options(options)
     end
 
     def self.finished_key(key)
@@ -40,11 +36,15 @@ module Split
     end
 
     def set_alternatives_and_options(options)
-      self.alternatives = options[:alternatives]
-      self.goals = options[:goals]
-      self.resettable = options[:resettable]
-      self.algorithm = options[:algorithm]
-      self.metadata = options[:metadata]
+      options_with_defaults = DEFAULT_OPTIONS.merge(
+        options.reject { |k, v| v.nil? }
+      )
+
+      self.alternatives = options_with_defaults[:alternatives]
+      self.goals = options_with_defaults[:goals]
+      self.resettable = options_with_defaults[:resettable]
+      self.algorithm = options_with_defaults[:algorithm]
+      self.metadata = options_with_defaults[:metadata]
     end
 
     def extract_alternatives_from_options(options)
@@ -52,7 +52,7 @@ module Split
 
       if alts.length == 1
         if alts[0].is_a? Hash
-          alts = alts[0].map{|k,v| {k => v} }
+          alts = alts[0].map{|k, v| {k => v} }
         end
       end
 
@@ -62,7 +62,7 @@ module Split
           alts = load_alternatives_from_configuration
           options[:goals] = Split::GoalsCollection.new(@name).load_from_configuration
           options[:metadata] = load_metadata_from_configuration
-          options[:resettable] = exp_config.fetch(:resettable, true)
+          options[:resettable] = exp_config[:resettable]
           options[:algorithm] = exp_config[:algorithm]
         end
       end
@@ -87,8 +87,8 @@ module Split
         persist_experiment_configuration
       end
 
-      redis.hset(experiment_config_key, :resettable, resettable)
-      redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
+      redis.hmset(experiment_config_key, :resettable, resettable,
+                                         :algorithm, algorithm.to_s)
       self
     end
 
@@ -101,7 +101,7 @@ module Split
     end
 
     def new_record?
-      !redis.exists(name)
+      ExperimentCatalog.find(name).nil?
     end
 
     def ==(obj)
@@ -135,11 +135,13 @@ module Split
     end
 
     def winner
-      experiment_winner = redis.hget(:experiment_winner, name)
-      if experiment_winner
-        Split::Alternative.new(experiment_winner, name)
-      else
-        nil
+      Split.cache(:experiment_winner, name) do
+        experiment_winner = redis.hget(:experiment_winner, name)
+        if experiment_winner
+          Split::Alternative.new(experiment_winner, name)
+        else
+          nil
+        end
       end
     end
 
@@ -151,10 +153,11 @@ module Split
     def winner=(winner_name)
       redis.hset(:experiment_winner, name, winner_name.to_s)
       @has_winner = true
+      Split.configuration.on_experiment_winner_choose.call(self)
     end
 
     def participant_count
-      alternatives.inject(0){|sum,a| sum + a.participant_count}
+      alternatives.inject(0){|sum, a| sum + a.participant_count}
     end
 
     def control
@@ -164,6 +167,7 @@ module Split
     def reset_winner
       redis.hdel(:experiment_winner, name)
       @has_winner = false
+      Split::Cache.clear_key(@name)
     end
 
     def start
@@ -171,13 +175,15 @@ module Split
     end
 
     def start_time
-      t = redis.hget(:experiment_start_times, @name)
-      if t
-        # Check if stored time is an integer
-        if t =~ /^[-+]?[0-9]+$/
-          Time.at(t.to_i)
-        else
-          Time.parse(t)
+      Split.cache(:experiment_start_times, @name) do
+        t = redis.hget(:experiment_start_times, @name)
+        if t
+          # Check if stored time is an integer
+          if t =~ /^[-+]?[0-9]+$/
+            Time.at(t.to_i)
+          else
+            Time.parse(t)
+          end
         end
       end
     end
@@ -228,6 +234,7 @@ module Split
 
     def reset
       Split.configuration.on_before_experiment_reset.call(self)
+      Split::Cache.clear_key(@name)
       alternatives.each(&:reset)
       reset_winner
       Split.configuration.on_experiment_reset.call(self)
@@ -241,6 +248,7 @@ module Split
       end
       reset_winner
       redis.srem(:experiments, name)
+      remove_experiment_cohorting
       remove_experiment_configuration
       Split.configuration.on_experiment_delete.call(self)
       increment_version
@@ -338,7 +346,7 @@ module Split
 
     def find_simulated_winner(simulated_cr_hash)
       # figure out which alternative had the highest simulated conversion rate
-      winning_pair = ["",0.0]
+      winning_pair = ["", 0.0]
       simulated_cr_hash.each do |alternative, rate|
         if rate > winning_pair[1]
           winning_pair = [alternative, rate]
@@ -349,17 +357,13 @@ module Split
     end
 
     def calc_simulated_conversion_rates(beta_params)
-      # initialize a random variable (from which to simulate conversion rates ~beta-distributed)
-      rand = SimpleRandom.new
-      rand.set_seed
-
       simulated_cr_hash = {}
 
       # create a hash which has the conversion rate pulled from each alternative's beta distribution
       beta_params.each do |alternative, params|
         alpha = params[0]
         beta = params[1]
-        simulated_conversion_rate = rand.beta(alpha, beta)
+        simulated_conversion_rate = Rubystats::BetaDistribution.new(alpha, beta).rng
         simulated_cr_hash[alternative] = simulated_conversion_rate
       end
 
@@ -397,6 +401,23 @@ module Split
       js_id.gsub('/', '--')
     end
 
+    def cohorting_disabled?
+      @cohorting_disabled ||= begin
+        value = redis.hget(experiment_config_key, :cohorting)
+        value.nil? ? false : value.downcase == "true"
+      end
+    end
+
+    def disable_cohorting
+      @cohorting_disabled = true
+      redis.hset(experiment_config_key, :cohorting, true)
+    end
+
+    def enable_cohorting
+      @cohorting_disabled = false
+      redis.hset(experiment_config_key, :cohorting, false)
+    end
+
     protected
 
     def experiment_config_key
@@ -423,15 +444,7 @@ module Split
     end
 
     def load_alternatives_from_redis
-      alternatives = case redis.type(@name)
-                     when 'set' # convert legacy sets to lists
-                       alts = redis.smembers(@name)
-                       redis.del(@name)
-                       alts.reverse.each {|a| redis.lpush(@name, a) }
-                       redis.lrange(@name, 0, -1)
-                     else
-                       redis.lrange(@name, 0, -1)
-                     end
+      alternatives = redis.lrange(@name, 0, -1)
       alternatives.map do |alt|
         alt = begin
                 JSON.parse(alt)
@@ -456,7 +469,12 @@ module Split
       redis_interface.add_to_set(:experiments, name)
       redis_interface.persist_list(name, @alternatives.map{|alt| {alt.name => alt.weight}.to_json})
       goals_collection.save
-      redis.set(metadata_key, @metadata.to_json) unless @metadata.nil?
+
+      if @metadata
+        redis.set(metadata_key, @metadata.to_json)
+      else
+        delete_metadata
+      end
     end
 
     def remove_experiment_configuration
@@ -467,16 +485,20 @@ module Split
     end
 
     def experiment_configuration_has_changed?
-      existing_alternatives = load_alternatives_from_redis
-      existing_goals = Split::GoalsCollection.new(@name).load_from_redis
-      existing_metadata = load_metadata_from_redis
-      existing_alternatives.map(&:to_s) != @alternatives.map(&:to_s) ||
-        existing_goals != @goals ||
-        existing_metadata != @metadata
+      existing_experiment = Experiment.find(@name)
+
+      existing_experiment.alternatives.map(&:to_s) != @alternatives.map(&:to_s) ||
+        existing_experiment.goals != @goals ||
+        existing_experiment.metadata != @metadata
     end
 
     def goals_collection
       Split::GoalsCollection.new(@name, @goals)
     end
+
+    def remove_experiment_cohorting
+      @cohorting_disabled = false
+      redis.hdel(experiment_config_key, :cohorting)
+    end
   end
 end

data/lib/split/experiment_catalog.rb

@@ -13,8 +13,7 @@ module Split
     end
 
     def self.find(name)
-      return unless Split.redis.exists(name)
-      Experiment.new(name).tap { |exp| exp.load_from_redis }
+      Experiment.find(name)
     end
 
     def self.find_or_initialize(metric_descriptor, control = nil, *alternatives)
@@ -46,6 +45,5 @@ module Split
       return experiment_name, goals
     end
     private_class_method :normalize_experiment
-
   end
 end

data/lib/split/extensions/string.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class String
   # Constatntize is often provided by ActiveSupport, but ActiveSupport is not a dependency of Split.
   unless method_defined?(:constantize)

data/lib/split/goals_collection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   class GoalsCollection
 

data/lib/split/helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Helper
     OVERRIDE_PARAM_NAME = "ab_test"
@@ -32,8 +33,8 @@ module Split
       end
 
       if block_given?
-        metadata = trial ? trial.metadata : {}
-        yield(alternative, metadata)
+        metadata = experiment.metadata[alternative] if experiment.metadata
+        yield(alternative, metadata || {})
       else
         alternative
       end
@@ -51,9 +52,14 @@ module Split
         return true
       else
         alternative_name = ab_user[experiment.key]
-        trial = Trial.new(:user => ab_user, :experiment => experiment,
-              :alternative => alternative_name)
-        trial.complete!(options[:goals], self)
+        trial = Trial.new(
+          :user => ab_user, 
+          :experiment => experiment,
+          :alternative => alternative_name,
+          :goals => options[:goals],
+        )      
+        
+        trial.complete!(self)
 
         if should_reset
           reset!(experiment)
@@ -70,6 +76,7 @@ module Split
 
       if experiments.any?
         experiments.each do |experiment|
+          next if override_present?(experiment.key)
           finish_experiment(experiment, options.merge(:goals => goals))
         end
       end
@@ -105,15 +112,27 @@ module Split
       Split.configuration.db_failover_on_db_error.call(e)
     end
 
-
     def override_present?(experiment_name)
-      override_alternative(experiment_name)
+      override_alternative_by_params(experiment_name) || override_alternative_by_cookies(experiment_name)
     end
 
     def override_alternative(experiment_name)
+      override_alternative_by_params(experiment_name) || override_alternative_by_cookies(experiment_name)
+    end
+
+    def override_alternative_by_params(experiment_name)
       defined?(params) && params[OVERRIDE_PARAM_NAME] && params[OVERRIDE_PARAM_NAME][experiment_name]
     end
 
+    def override_alternative_by_cookies(experiment_name)
+      return unless defined?(request)
+
+      if request.cookies && request.cookies.key?('split_override')
+        experiments = JSON.parse(request.cookies['split_override']) rescue {}
+        experiments[experiment_name]
+      end
+    end
+
     def split_generically_disabled?
       defined?(params) && params['SPLIT_DISABLE']
     end

data/lib/split/metric.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 module Split
   class Metric
     attr_accessor :name
     attr_accessor :experiments
 
     def initialize(attrs = {})
-      attrs.each do |key,value|
+      attrs.each do |key, value|
         if self.respond_to?("#{key}=")
           self.send("#{key}=", value)
         end

data/lib/split/persistence/cookie_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "json"
 
 module Split
@@ -44,7 +45,7 @@ module Split
       end
 
       def default_options
-        { expires: @expires, path: '/' }
+        { expires: @expires, path: '/', domain: cookie_domain_config }.compact
       end
 
       def set_cookie_via_rack(key, value)
@@ -86,6 +87,10 @@ module Split
         Split.configuration.persistence_cookie_length
       end
 
+      def cookie_domain_config
+        Split.configuration.persistence_cookie_domain
+      end
+
       def action_dispatch?
         defined?(Rails) && @response.is_a?(ActionDispatch::Response)
       end

data/lib/split/persistence/redis_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class RedisAdapter
@@ -39,6 +40,10 @@ module Split
         Split.redis.hkeys(redis_key)
       end
 
+      def self.find(user_id)
+        new(nil, user_id)
+      end
+
       def self.with_config(options={})
         self.config.merge!(options)
         self

data/lib/split/persistence/session_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class SessionAdapter

data/lib/split/persistence.rb

@@ -8,8 +8,10 @@ module Split
     require 'split/persistence/session_adapter'
 
     ADAPTERS = {
-      :cookie => Split::Persistence::CookieAdapter,
-      :session => Split::Persistence::SessionAdapter
+      cookie: Split::Persistence::CookieAdapter,
+      session: Split::Persistence::SessionAdapter,
+      redis: Split::Persistence::RedisAdapter,
+      dual_adapter: Split::Persistence::DualAdapter
     }.freeze
 
     def self.adapter

data/lib/split/redis_interface.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   # Simplifies the interface to Redis.
   class RedisInterface
@@ -7,40 +8,19 @@ module Split
     end
 
     def persist_list(list_name, list_values)
-      max_index = list_length(list_name) - 1
-      list_values.each_with_index do |value, index|
-        if index > max_index
-          add_to_list(list_name, value)
-        else
-          set_list_index(list_name, index, value)
+      if list_values.length > 0
+        redis.multi do |multi|
+          tmp_list = "#{list_name}_tmp"
+          multi.rpush(tmp_list, list_values)
+          multi.rename(tmp_list, list_name)
         end
       end
-      make_list_length(list_name, list_values.length)
-      list_values
-    end
-
-    def add_to_list(list_name, value)
-      redis.rpush(list_name, value)
-    end
-
-    def set_list_index(list_name, index, value)
-      redis.lset(list_name, index, value)
-    end
-
-    def list_length(list_name)
-      redis.llen(list_name)
-    end
 
-    def remove_last_item_from_list(list_name)
-      redis.rpop(list_name)
-    end
-
-    def make_list_length(list_name, new_length)
-      redis.ltrim(list_name, 0, new_length - 1)
+      list_values
     end
 
     def add_to_set(set_name, value)
-      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+      redis.sadd(set_name, value)
     end
 
     private

data/lib/split/trial.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 module Split
   class Trial
+    attr_accessor :goals
     attr_accessor :experiment
     attr_writer :metadata
 
@@ -8,11 +10,12 @@ module Split
       self.experiment   = attrs.delete(:experiment)
       self.alternative  = attrs.delete(:alternative)
       self.metadata  = attrs.delete(:metadata)
+      self.goals = attrs.delete(:goals) || []
 
       @user             = attrs.delete(:user)
       @options          = attrs
 
-      @alternative_choosen = false
+      @alternative_chosen = false
     end
 
     def metadata
@@ -33,7 +36,7 @@ module Split
       end
     end
 
-    def complete!(goals=[], context = nil)
+    def complete!(context = nil)
       if alternative
         if Array(goals).empty?
           alternative.increment_completion
@@ -51,8 +54,9 @@ module Split
     def choose!(context = nil)
       @user.cleanup_old_experiments!
       # Only run the process once
-      return alternative if @alternative_choosen
+      return alternative if @alternative_chosen
 
+      new_participant = @user[@experiment.key].nil?
       if override_is_alternative?
         self.alternative = @options[:override]
         if should_store_alternative? && !@user[@experiment.key]
@@ -70,19 +74,25 @@ module Split
         else
           self.alternative = @user[@experiment.key]
           if alternative.nil?
-            self.alternative = @experiment.next_alternative
+            if @experiment.cohorting_disabled?
+              self.alternative = @experiment.control
+            else
+              self.alternative = @experiment.next_alternative
 
-            # Increment the number of participants since we are actually choosing a new alternative
-            self.alternative.increment_participation
+              # Increment the number of participants since we are actually choosing a new alternative
+              self.alternative.increment_participation
 
-            run_callback context, Split.configuration.on_trial_choose
+              run_callback context, Split.configuration.on_trial_choose
+            end
           end
         end
       end
 
-      @user[@experiment.key] = alternative.name if !@experiment.has_winner? && should_store_alternative?
-      @alternative_choosen = true
-      run_callback context, Split.configuration.on_trial unless @options[:disabled] || Split.configuration.disabled?
+      new_participant_and_cohorting_disabled = new_participant && @experiment.cohorting_disabled?
+
+      @user[@experiment.key] = alternative.name unless @experiment.has_winner? || !should_store_alternative? || new_participant_and_cohorting_disabled
+      @alternative_chosen = true
+      run_callback context, Split.configuration.on_trial unless @options[:disabled] || Split.configuration.disabled? || new_participant_and_cohorting_disabled
       alternative
     end
 

data/lib/split/user.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'forwardable'
 
 module Split
@@ -7,7 +8,7 @@ module Split
     def_delegators :@user, :keys, :[], :[]=, :delete
     attr_reader :user
 
-    def initialize(context, adapter=nil)
+    def initialize(context, adapter = nil)
       @user = adapter || Split::Persistence.adapter.new(context)
       @cleaned_up = false
     end
@@ -27,7 +28,8 @@ module Split
     def max_experiments_reached?(experiment_key)
       if Split.configuration.allow_multiple_experiments == 'control'
         experiments = active_experiments
-        count_control = experiments.count {|k,v| k == experiment_key || v == 'control'}
+        experiment_key_without_version = key_without_version(experiment_key)
+        count_control = experiments.count {|k, v| k == experiment_key_without_version || v == 'control'}
         experiments.size > count_control
       else
         !Split.configuration.allow_multiple_experiments &&
@@ -36,7 +38,7 @@ module Split
     end
 
     def cleanup_old_versions!(experiment)
-      keys = user.keys.select { |k| k.match(Regexp.new(experiment.name)) }
+      keys = user.keys.select { |k| key_without_version(k) == experiment.name }
       keys_without_experiment(keys, experiment.key).each { |key| user.delete(key) }
     end
 
@@ -52,6 +54,16 @@ module Split
       experiment_pairs
     end
 
+    def self.find(user_id, adapter)
+      adapter = adapter.is_a?(Symbol) ? Split::Persistence::ADAPTERS[adapter] : adapter
+
+      if adapter.respond_to?(:find)
+        User.new(nil, adapter.find(user_id))
+      else
+        nil
+      end
+    end
+
     private
 
     def keys_without_experiment(keys, experiment_key)

data/lib/split/version.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
+
 module Split
-  MAJOR   = 3
-  MINOR   = 4
-  PATCH   = 0
-  VERSION = [MAJOR, MINOR, PATCH].join('.')
+  VERSION = "4.0.1"
 end

data/lib/split/zscore.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   class Zscore