ab-split 1.0.0

data/lib/split/persistence/dual_adapter.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Split
+  module Persistence
+    class DualAdapter
+      def self.with_config(options={})
+        self.config.merge!(options)
+        self
+      end
+
+      def self.config
+        @config ||= {}
+      end
+
+      def initialize(context)
+        if logged_in = self.class.config[:logged_in]
+        else
+          raise "Please configure :logged_in"
+        end
+        if logged_in_adapter = self.class.config[:logged_in_adapter]
+        else
+          raise "Please configure :logged_in_adapter"
+        end
+        if logged_out_adapter = self.class.config[:logged_out_adapter]
+        else
+          raise "Please configure :logged_out_adapter"
+        end
+
+        @fallback_to_logged_out_adapter =
+          self.class.config[:fallback_to_logged_out_adapter] || false
+        @logged_in = logged_in.call(context)
+        @logged_in_adapter = logged_in_adapter.new(context)
+        @logged_out_adapter = logged_out_adapter.new(context)
+        @active_adapter = @logged_in ? @logged_in_adapter : @logged_out_adapter
+      end
+
+      def keys
+        if @fallback_to_logged_out_adapter
+          (@logged_in_adapter.keys + @logged_out_adapter.keys).uniq
+        else
+          @active_adapter.keys
+        end
+      end
+
+      def [](key)
+        if @fallback_to_logged_out_adapter
+          @logged_in && @logged_in_adapter[key] || @logged_out_adapter[key]
+        else
+          @active_adapter[key]
+        end
+      end
+
+      def []=(key, value)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter[key] = value if @logged_in
+          old_value = @logged_out_adapter[key]
+          @logged_out_adapter[key] = value
+
+          decrement_participation(key, old_value) if decrement_participation?(old_value, value)
+        else
+          @active_adapter[key] = value
+        end
+      end
+
+      def delete(key)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter.delete(key)
+          @logged_out_adapter.delete(key)
+        else
+          @active_adapter.delete(key)
+        end
+      end
+
+      private
+
+      def decrement_participation?(old_value, value)
+        !old_value.nil? && !value.nil? && old_value != value
+      end
+
+      def decrement_participation(key, value)
+        Split.redis.hincrby("#{key}:#{value}", 'participant_count', -1)
+      end
+    end
+  end
+end

data/lib/split/persistence/redis_adapter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module Split
+  module Persistence
+    class RedisAdapter
+      DEFAULT_CONFIG = {:namespace => 'persistence'}.freeze
+
+      attr_reader :redis_key
+
+      def initialize(context, key = nil)
+        if key
+          @redis_key = "#{self.class.config[:namespace]}:#{key}"
+        elsif lookup_by = self.class.config[:lookup_by]
+          if lookup_by.respond_to?(:call)
+            key_frag = lookup_by.call(context)
+          else
+            key_frag = context.send(lookup_by)
+          end
+          @redis_key = "#{self.class.config[:namespace]}:#{key_frag}"
+        else
+          raise "Please configure lookup_by"
+        end
+      end
+
+      def [](field)
+        Split.redis.hget(redis_key, field)
+      end
+
+      def []=(field, value)
+        Split.redis.hset(redis_key, field, value)
+        expire_seconds = self.class.config[:expire_seconds]
+        Split.redis.expire(redis_key, expire_seconds) if expire_seconds
+      end
+
+      def delete(field)
+        Split.redis.hdel(redis_key, field)
+      end
+
+      def keys
+        Split.redis.hkeys(redis_key)
+      end
+
+      def self.with_config(options={})
+        self.config.merge!(options)
+        self
+      end
+
+      def self.config
+        @config ||= DEFAULT_CONFIG.dup
+      end
+
+      def self.reset_config!
+        @config = DEFAULT_CONFIG.dup
+      end
+
+    end
+  end
+end

data/lib/split/persistence/session_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Split
+  module Persistence
+    class SessionAdapter
+
+      def initialize(context)
+        @session = context.session
+        @session[:split] ||= {}
+      end
+
+      def [](key)
+        @session[:split][key]
+      end
+
+      def []=(key, value)
+        @session[:split][key] = value
+      end
+
+      def delete(key)
+        @session[:split].delete(key)
+      end
+
+      def keys
+        @session[:split].keys
+      end
+
+    end
+  end
+end

data/lib/split/redis_interface.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Split
+  # Simplifies the interface to Redis.
+  class RedisInterface
+    def initialize
+      self.redis = Split.redis
+    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)
+        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)
+    end
+
+    def add_to_set(set_name, value)
+      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+    end
+
+    private
+
+    attr_accessor :redis
+  end
+end

data/lib/split/trial.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+module Split
+  class Trial
+    attr_accessor :experiment
+    attr_writer :metadata
+
+    def initialize(attrs = {})
+      self.experiment   = attrs.delete(:experiment)
+      self.alternative  = attrs.delete(:alternative)
+      self.metadata  = attrs.delete(:metadata)
+
+      @user             = attrs.delete(:user)
+      @options          = attrs
+
+      @alternative_choosen = false
+    end
+
+    def metadata
+      @metadata ||= experiment.metadata[alternative.name] if experiment.metadata
+    end
+
+    def alternative
+      @alternative ||=  if @experiment.has_winner?
+                          @experiment.winner
+                        end
+    end
+
+    def alternative=(alternative)
+      @alternative = if alternative.kind_of?(Split::Alternative)
+        alternative
+      else
+        @experiment.alternatives.find{|a| a.name == alternative }
+      end
+    end
+
+    def complete!(goals=[], context = nil)
+      if alternative
+        if Array(goals).empty?
+          alternative.increment_completion
+        else
+          Array(goals).each {|g| alternative.increment_completion(g) }
+        end
+
+        run_callback context, Split.configuration.on_trial_complete
+      end
+    end
+
+    # Choose an alternative, add a participant, and save the alternative choice on the user. This
+    # method is guaranteed to only run once, and will skip the alternative choosing process if run
+    # a second time.
+    def choose!(context = nil)
+      @user.cleanup_old_experiments!
+      # Only run the process once
+      return alternative if @alternative_choosen
+
+      if override_is_alternative?
+        self.alternative = @options[:override]
+        if should_store_alternative? && !@user[@experiment.key]
+          self.alternative.increment_participation
+        end
+      elsif @options[:disabled] || Split.configuration.disabled?
+        self.alternative = @experiment.control
+      elsif @experiment.has_winner?
+        self.alternative = @experiment.winner
+      else
+        cleanup_old_versions
+
+        if exclude_user?
+          self.alternative = @experiment.control
+        else
+          self.alternative = @user[@experiment.key]
+          if alternative.nil?
+            self.alternative = @experiment.next_alternative
+
+            # 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
+          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?
+      alternative
+    end
+
+    private
+
+    def run_callback(context, callback_name)
+      context.send(callback_name, self) if callback_name && context.respond_to?(callback_name, true)
+    end
+
+    def override_is_alternative?
+      @experiment.alternatives.map(&:name).include?(@options[:override])
+    end
+
+    def should_store_alternative?
+      if @options[:override] || @options[:disabled]
+        Split.configuration.store_override
+      else
+        !exclude_user?
+      end
+    end
+
+    def cleanup_old_versions
+      if @experiment.version > 0
+        @user.cleanup_old_versions!(@experiment)
+      end
+    end
+
+    def exclude_user?
+      @options[:exclude] || @experiment.start_time.nil? || @user.max_experiments_reached?(@experiment.key)
+    end
+  end
+end

data/lib/split/user.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'forwardable'
+
+module Split
+  class User
+    extend Forwardable
+    def_delegators :@user, :keys, :[], :[]=, :delete
+    attr_reader :user
+
+    def initialize(context, adapter=nil)
+      @user = adapter || Split::Persistence.adapter.new(context)
+      @cleaned_up = false
+    end
+
+    def cleanup_old_experiments!
+      return if @cleaned_up
+      keys_without_finished(user.keys).each do |key|
+        experiment = ExperimentCatalog.find key_without_version(key)
+        if experiment.nil? || experiment.has_winner? || experiment.start_time.nil?
+          user.delete key
+          user.delete Experiment.finished_key(key)
+        end
+      end
+      @cleaned_up = true
+    end
+
+    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'}
+        experiments.size > count_control
+      else
+        !Split.configuration.allow_multiple_experiments &&
+          keys_without_experiment(user.keys, experiment_key).length > 0
+      end
+    end
+
+    def cleanup_old_versions!(experiment)
+      keys = user.keys.select { |k| k.match(Regexp.new(experiment.name)) }
+      keys_without_experiment(keys, experiment.key).each { |key| user.delete(key) }
+    end
+
+    def active_experiments
+      experiment_pairs = {}
+      keys_without_finished(user.keys).each do |key|
+        Metric.possible_experiments(key_without_version(key)).each do |experiment|
+          if !experiment.has_winner?
+            experiment_pairs[key_without_version(key)] = user[key]
+          end
+        end
+      end
+      experiment_pairs
+    end
+
+    private
+
+    def keys_without_experiment(keys, experiment_key)
+      keys.reject { |k| k.match(Regexp.new("^#{experiment_key}(:finished)?$")) }
+    end
+
+    def keys_without_finished(keys)
+      keys.reject { |k| k.include?(":finished") }
+    end
+
+    def key_without_version(key)
+      key.split(/\:\d(?!\:)/)[0]
+    end
+  end
+end

data/lib/split/version.rb

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

data/lib/split/zscore.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module Split
+  class Zscore
+
+    include Math
+
+    def self.calculate(p1, n1, p2, n2)
+      # p_1 = Pa = proportion of users who converted within the experiment split (conversion rate)
+      # p_2 = Pc = proportion of users who converted within the control split (conversion rate)
+      # n_1 = Na = the number of impressions within the experiment split
+      # n_2 = Nc = the number of impressions within the control split
+      # s_1 = SEa = standard error of p_1, the estiamte of the mean
+      # s_2 = SEc = standard error of p_2, the estimate of the control
+      # s_p = SEp = standard error of p_1 - p_2, assuming a pooled variance
+      # s_unp = SEunp = standard error of p_1 - p_2, assuming unpooled variance
+
+      p_1 = p1.to_f
+      p_2 = p2.to_f
+
+      n_1 = n1.to_f
+      n_2 = n2.to_f
+
+      # Perform checks on data to make sure we can validly run our confidence tests
+      if n_1 < 30 || n_2 < 30
+        error = "Needs 30+ participants."
+        return error
+      elsif p_1 * n_1 < 5 || p_2 * n_2 < 5
+        error = "Needs 5+ conversions."
+        return error
+      end
+
+      # Formula for standard error: root(pq/n) = root(p(1-p)/n)
+      s_1 = Math.sqrt((p_1)*(1-p_1)/(n_1))
+      s_2 = Math.sqrt((p_2)*(1-p_2)/(n_2))
+
+      # Formula for pooled error of the difference of the means: root(π*(1-π)*(1/na+1/nc)
+      # π = (xa + xc) / (na + nc)
+      pi = (p_1*n_1 + p_2*n_2)/(n_1 + n_2)
+      s_p = Math.sqrt(pi*(1-pi)*(1/n_1 + 1/n_2))
+
+      # Formula for unpooled error of the difference of the means: root(sa**2/na + sc**2/nc)
+      s_unp = Math.sqrt(s_1**2 + s_2**2)
+
+      # Boolean variable decides whether we can pool our variances
+      pooled = s_1/s_2 < 2 && s_2/s_1 < 2
+
+      # Assign standard error either the pooled or unpooled variance
+      se = pooled ? s_p : s_unp
+
+      # Calculate z-score
+      z_score = (p_1 - p_2)/(se)
+
+      return z_score
+
+    end
+  end
+end