split 3.2.0 → 4.0.5

data/lib/split/experiment.rb

@@ -1,38 +1,32 @@
 # frozen_string_literal: true
+
 module Split
   class Experiment
     attr_accessor :name
-    attr_writer :algorithm
-    attr_accessor :resettable
     attr_accessor :goals
-    attr_accessor :alternatives
     attr_accessor :alternative_probabilities
     attr_accessor :metadata
 
+    attr_reader :alternatives
+    attr_reader :resettable
+
     DEFAULT_OPTIONS = {
-      :resettable => true
+      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[:resettable],
-          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 +34,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 +50,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
 
@@ -81,14 +79,14 @@ module Split
 
       if new_record?
         start unless Split.configuration.start_manually
+        persist_experiment_configuration
       elsif experiment_configuration_has_changed?
         reset unless Split.configuration.reset_manually
+        persist_experiment_configuration
       end
 
-      persist_experiment_configuration if new_record? || experiment_configuration_has_changed?
-
-      redis.hset(experiment_config_key, :resettable, resettable)
-      redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
+      redis.hmset(experiment_config_key, :resettable, resettable.to_s,
+                                         :algorithm, algorithm.to_s)
       self
     end
 
@@ -96,12 +94,12 @@ module Split
       if @alternatives.empty? && Split.configuration.experiment_for(@name).nil?
         raise ExperimentNotFound.new("Experiment #{@name} not found")
       end
-      @alternatives.each {|a| a.validate! }
+      @alternatives.each { |a| a.validate! }
       goals_collection.validate!
     end
 
     def new_record?
-      !redis.exists(name)
+      ExperimentCatalog.find(name).nil?
     end
 
     def ==(obj)
@@ -109,7 +107,7 @@ module Split
     end
 
     def [](name)
-      alternatives.find{|a| a.name == name}
+      alternatives.find { |a| a.name == name }
     end
 
     def algorithm
@@ -121,7 +119,7 @@ module Split
     end
 
     def resettable=(resettable)
-      @resettable = resettable.is_a?(String) ? resettable == 'true' : resettable
+      @resettable = resettable.is_a?(String) ? resettable == "true" : resettable
     end
 
     def alternatives=(alts)
@@ -135,24 +133,29 @@ 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
 
     def has_winner?
-      !winner.nil?
+      return @has_winner if defined? @has_winner
+      @has_winner = !winner.nil?
     end
 
     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
@@ -161,6 +164,8 @@ module Split
 
     def reset_winner
       redis.hdel(:experiment_winner, name)
+      @has_winner = false
+      Split::Cache.clear_key(@name)
     end
 
     def start
@@ -168,13 +173,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
@@ -225,6 +232,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)
@@ -238,6 +246,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
@@ -251,8 +260,8 @@ module Split
       exp_config = redis.hgetall(experiment_config_key)
 
       options = {
-        resettable: exp_config['resettable'],
-        algorithm: exp_config['algorithm'],
+        resettable: exp_config["resettable"],
+        algorithm: exp_config["algorithm"],
         alternatives: load_alternatives_from_redis,
         goals: Split::GoalsCollection.new(@name).load_from_redis,
         metadata: load_metadata_from_redis
@@ -261,7 +270,16 @@ module Split
       set_alternatives_and_options(options)
     end
 
+    def can_calculate_winning_alternatives?
+      self.alternatives.all? do |alternative|
+        alternative.participant_count >= 0 &&
+        (alternative.participant_count >= alternative.completed_count)
+      end
+    end
+
     def calc_winning_alternatives
+      return unless can_calculate_winning_alternatives?
+
       # Cache the winning alternatives so we recalculate them once per the specified interval.
       intervals_since_epoch =
         Time.now.utc.to_i / Split.configuration.winning_alternative_recalculation_interval
@@ -317,11 +335,11 @@ module Split
       winning_counts.each do |alternative, wins|
         alternative_probabilities[alternative] = wins / number_of_simulations.to_f
       end
-      return alternative_probabilities
+      alternative_probabilities
     end
 
     def count_simulated_wins(winning_alternatives)
-       # initialize a hash to keep track of winning alternative in simulations
+      # initialize a hash to keep track of winning alternative in simulations
       winning_counts = {}
       alternatives.each do |alternative|
         winning_counts[alternative] = 0
@@ -330,37 +348,33 @@ module Split
       winning_alternatives.each do |alternative|
         winning_counts[alternative] += 1
       end
-      return winning_counts
+      winning_counts
     end
 
     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]
         end
       end
       winner = winning_pair[0]
-      return winner
+      winner
     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 = Split::Algorithms.beta_distribution_rng(alpha, beta)
         simulated_cr_hash[alternative] = simulated_conversion_rate
       end
 
-      return simulated_cr_hash
+      simulated_cr_hash
     end
 
     def calc_beta_params(goal = nil)
@@ -374,7 +388,7 @@ module Split
 
         beta_params[alternative] = params
       end
-      return beta_params
+      beta_params
     end
 
     def calc_time=(time)
@@ -387,85 +401,109 @@ module Split
 
     def jstring(goal = nil)
       js_id = if goal.nil?
-                name
-              else
-                name + "-" + goal
-              end
-      js_id.gsub('/', '--')
+        name
+      else
+        name + "-" + goal
+      end
+      js_id.gsub("/", "--")
     end
 
-    protected
-
-    def experiment_config_key
-      "experiment_configurations/#{@name}"
+    def cohorting_disabled?
+      @cohorting_disabled ||= begin
+        value = redis.hget(experiment_config_key, :cohorting)
+        value.nil? ? false : value.downcase == "true"
+      end
     end
 
-    def load_metadata_from_configuration
-      Split.configuration.experiment_for(@name)[:metadata]
+    def disable_cohorting
+      @cohorting_disabled = true
+      redis.hset(experiment_config_key, :cohorting, true.to_s)
     end
 
-    def load_metadata_from_redis
-      meta = redis.get(metadata_key)
-      JSON.parse(meta) unless meta.nil?
+    def enable_cohorting
+      @cohorting_disabled = false
+      redis.hset(experiment_config_key, :cohorting, false.to_s)
     end
 
-    def load_alternatives_from_configuration
-      alts = Split.configuration.experiment_for(@name)[:alternatives]
-      raise ArgumentError, "Experiment configuration is missing :alternatives array" unless alts
-      if alts.is_a?(Hash)
-        alts.keys
-      else
-        alts.flatten
+    protected
+      def experiment_config_key
+        "experiment_configurations/#{@name}"
       end
-    end
 
-    def load_alternatives_from_redis
-      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)
+      def load_metadata_from_configuration
+        Split.configuration.experiment_for(@name)[:metadata]
+      end
+
+      def load_metadata_from_redis
+        meta = redis.get(metadata_key)
+        JSON.parse(meta) unless meta.nil?
+      end
+
+      def load_alternatives_from_configuration
+        alts = Split.configuration.experiment_for(@name)[:alternatives]
+        raise ArgumentError, "Experiment configuration is missing :alternatives array" unless alts
+        if alts.is_a?(Hash)
+          alts.keys
+        else
+          alts.flatten
+        end
+      end
+
+      def load_alternatives_from_redis
+        alternatives = redis.lrange(@name, 0, -1)
+        alternatives.map do |alt|
+          alt = begin
+                  JSON.parse(alt)
+                rescue
+                  alt
+                end
+          Split::Alternative.new(alt, @name)
+        end
       end
-    end
 
     private
+      def redis
+        Split.redis
+      end
 
-    def redis
-      Split.redis
-    end
+      def redis_interface
+        RedisInterface.new
+      end
 
-    def redis_interface
-      RedisInterface.new
-    end
+      def persist_experiment_configuration
+        redis_interface.add_to_set(:experiments, name)
+        redis_interface.persist_list(name, @alternatives.map { |alt| { alt.name => alt.weight }.to_json })
+        goals_collection.save
 
-    def persist_experiment_configuration
-      redis_interface.add_to_set(:experiments, name)
-      redis_interface.persist_list(name, @alternatives.map(&:name))
-      goals_collection.save
-      redis.set(metadata_key, @metadata.to_json) unless @metadata.nil?
-    end
+        if @metadata
+          redis.set(metadata_key, @metadata.to_json)
+        else
+          delete_metadata
+        end
+      end
 
-    def remove_experiment_configuration
-      @alternatives.each(&:delete)
-      goals_collection.delete
-      delete_metadata
-      redis.del(@name)
-    end
+      def remove_experiment_configuration
+        @alternatives.each(&:delete)
+        goals_collection.delete
+        delete_metadata
+        redis.del(@name)
+      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 != @alternatives.map(&:name) ||
-        existing_goals != @goals ||
-        existing_metadata != @metadata
-    end
+      def experiment_configuration_has_changed?
+        existing_experiment = Experiment.find(@name)
 
-    def goals_collection
-      Split::GoalsCollection.new(@name, @goals)
-    end
+        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

@@ -1,33 +1,33 @@
 # frozen_string_literal: true
+
 module Split
   class ExperimentCatalog
     # Return all experiments
     def self.all
       # Call compact to prevent nil experiments from being returned -- seems to happen during gem upgrades
-      Split.redis.smembers(:experiments).map {|e| find(e)}.compact
+      Split.redis.smembers(:experiments).map { |e| find(e) }.compact
     end
 
     # Return experiments without a winner (considered "active") first
     def self.all_active_first
-      all.partition{|e| not e.winner}.map{|es| es.sort_by(&:name)}.flatten
+      all.partition { |e| not e.winner }.map { |es| es.sort_by(&:name) }.flatten
     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)
       # Check if array is passed to ab_test
       # e.g. ab_test('name', ['Alt 1', 'Alt 2', 'Alt 3'])
-      if control.is_a? Array and alternatives.length.zero?
+      if control.is_a?(Array) && alternatives.length.zero?
         control, alternatives = control.first, control[1..-1]
       end
 
       experiment_name_with_version, goals = normalize_experiment(metric_descriptor)
-      experiment_name = experiment_name_with_version.to_s.split(':')[0]
+      experiment_name = experiment_name_with_version.to_s.split(":")[0]
       Split::Experiment.new(experiment_name,
-          :alternatives => [control].compact + alternatives, :goals => goals)
+          alternatives: [control].compact + alternatives, goals: goals)
     end
 
     def self.find_or_create(metric_descriptor, control = nil, *alternatives)
@@ -46,6 +46,5 @@ module Split
       return experiment_name, goals
     end
     private_class_method :normalize_experiment
-
   end
 end

data/lib/split/extensions/string.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 class String
   # Constatntize is often provided by ActiveSupport, but ActiveSupport is not a dependency of Split.
   unless method_defined?(:constantize)
     def constantize
-      names = self.split('::')
+      names = self.split("::")
       names.shift if names.empty? || names.first.empty?
 
       constant = Object

data/lib/split/goals_collection.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Split
   class GoalsCollection
-
-    def initialize(experiment_name, goals=nil)
+    def initialize(experiment_name, goals = nil)
       @experiment_name = experiment_name
       @goals = goals
     end
@@ -13,10 +14,10 @@ module Split
     def load_from_configuration
       goals = Split.configuration.experiment_for(@experiment_name)[:goals]
 
-      if goals.nil?
-        goals = []
-      else
+      if goals
         goals.flatten
+      else
+        []
       end
     end
 
@@ -27,7 +28,7 @@ module Split
 
     def validate!
       unless @goals.nil? || @goals.kind_of?(Array)
-        raise ArgumentError, 'Goals must be an array'
+        raise ArgumentError, "Goals must be an array"
       end
     end
 
@@ -36,9 +37,8 @@ module Split
     end
 
     private
-
-    def goals_key
-      "#{@experiment_name}:goals"
-    end
+      def goals_key
+        "#{@experiment_name}:goals"
+      end
   end
 end