split 3.2.0 → 4.0.5

data/lib/split/helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Helper
     OVERRIDE_PARAM_NAME = "ab_test"
@@ -8,12 +9,12 @@ module Split
     def ab_test(metric_descriptor, control = nil, *alternatives)
       begin
         experiment = ExperimentCatalog.find_or_initialize(metric_descriptor, control, *alternatives)
-        alternative = if Split.configuration.enabled
+        alternative = if Split.configuration.enabled && !exclude_visitor?
           experiment.save
           raise(Split::InvalidExperimentsFormatError) unless (Split.configuration.experiments || {}).fetch(experiment.name.to_sym, {})[:combined_experiments].nil?
-          trial = Trial.new(:user => ab_user, :experiment => experiment,
-              :override => override_alternative(experiment.name), :exclude => exclude_visitor?,
-              :disabled => split_generically_disabled?)
+          trial = Trial.new(user: ab_user, experiment: experiment,
+              override: override_alternative(experiment.name), exclude: exclude_visitor?,
+              disabled: split_generically_disabled?)
           alt = trial.choose!(self)
           alt ? alt.name : nil
         else
@@ -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
@@ -43,16 +44,22 @@ module Split
       ab_user.delete(experiment.key)
     end
 
-    def finish_experiment(experiment, options = {:reset => true})
+    def finish_experiment(experiment, options = { reset: true })
+      return false if active_experiments[experiment.name].nil?
       return true if experiment.has_winner?
       should_reset = experiment.resettable? && options[:reset]
       if ab_user[experiment.finished_key] && !should_reset
-        return true
+        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)
@@ -62,14 +69,15 @@ module Split
       end
     end
 
-    def ab_finished(metric_descriptor, options = {:reset => true})
+    def ab_finished(metric_descriptor, options = { reset: true })
       return if exclude_visitor? || Split.configuration.disabled?
       metric_descriptor, goals = normalize_metric(metric_descriptor)
       experiments = Metric.possible_experiments(metric_descriptor)
 
       if experiments.any?
         experiments.each do |experiment|
-          finish_experiment(experiment, options.merge(:goals => goals))
+          next if override_present?(experiment.key)
+          finish_experiment(experiment, options.merge(goals: goals))
         end
       end
     rescue => e
@@ -78,8 +86,8 @@ module Split
     end
 
     def ab_record_extra_info(metric_descriptor, key, value = 1)
-      return if exclude_visitor? || Split.configuration.disabled?
-      metric_descriptor, goals = normalize_metric(metric_descriptor)
+      return if exclude_visitor? || Split.configuration.disabled? || value.nil?
+      metric_descriptor, _ = normalize_metric(metric_descriptor)
       experiments = Metric.possible_experiments(metric_descriptor)
 
       if experiments.any?
@@ -87,7 +95,7 @@ module Split
           alternative_name = ab_user[experiment.key]
 
           if alternative_name
-            alternative = experiment.alternatives.find{|alt| alt.name == alternative_name}
+            alternative = experiment.alternatives.find { |alt| alt.name == alternative_name }
             alternative.record_extra_info(key, value) if alternative
           end
         end
@@ -97,24 +105,36 @@ module Split
       Split.configuration.db_failover_on_db_error.call(e)
     end
 
-    def ab_active_experiments()
+    def ab_active_experiments
       ab_user.active_experiments
     rescue => e
       raise unless Split.configuration.db_failover
       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)
-      defined?(params) && params[OVERRIDE_PARAM_NAME] && params[OVERRIDE_PARAM_NAME][experiment_name]
+      override_alternative_by_params(experiment_name) || override_alternative_by_cookies(experiment_name)
+    end
+
+    def override_alternative_by_params(experiment_name)
+      params_present? && params[OVERRIDE_PARAM_NAME] && params[OVERRIDE_PARAM_NAME][experiment_name]
+    end
+
+    def override_alternative_by_cookies(experiment_name)
+      return unless request_present?
+
+      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']
+      params_present? && params["SPLIT_DISABLE"]
     end
 
     def ab_user
@@ -122,22 +142,34 @@ module Split
     end
 
     def exclude_visitor?
-      instance_eval(&Split.configuration.ignore_filter) || is_ignored_ip_address? || is_robot?
+      request_present? && (instance_exec(request, &Split.configuration.ignore_filter) || is_ignored_ip_address? || is_robot? || is_preview?)
     end
 
     def is_robot?
-      defined?(request) && request.user_agent =~ Split.configuration.robot_regex
+      request_present? && request.user_agent =~ Split.configuration.robot_regex
+    end
+
+    def is_preview?
+      request_present? && defined?(request.headers) && request.headers["x-purpose"] == "preview"
     end
 
     def is_ignored_ip_address?
       return false if Split.configuration.ignore_ip_addresses.empty?
 
       Split.configuration.ignore_ip_addresses.each do |ip|
-        return true if defined?(request) && (request.ip == ip || (ip.class == Regexp && request.ip =~ ip))
+        return true if request_present? && (request.ip == ip || (ip.class == Regexp && request.ip =~ ip))
       end
       false
     end
 
+    def params_present?
+      defined?(params) && params
+    end
+
+    def request_present?
+      defined?(request) && request
+    end
+
     def active_experiments
       ab_user.active_experiments
     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
@@ -15,13 +16,13 @@ module Split
     def self.load_from_redis(name)
       metric = Split.redis.hget(:metrics, name)
       if metric
-        experiment_names = metric.split(',')
+        experiment_names = metric.split(",")
 
         experiments = experiment_names.collect do |experiment_name|
           Split::ExperimentCatalog.find(experiment_name)
         end
 
-        Split::Metric.new(:name => name, :experiments => experiments)
+        Split::Metric.new(name: name, experiments: experiments)
       else
         nil
       end
@@ -30,7 +31,7 @@ module Split
     def self.load_from_configuration(name)
       metrics = Split.configuration.metrics
       if metrics && metrics[name]
-        Split::Metric.new(:experiments => metrics[name], :name => name)
+        Split::Metric.new(experiments: metrics[name], name: name)
       else
         nil
       end
@@ -76,7 +77,7 @@ module Split
     end
 
     def save
-      Split.redis.hset(:metrics, name, experiments.map(&:name).join(','))
+      Split.redis.hset(:metrics, name, experiments.map(&:name).join(","))
     end
 
     def complete!
@@ -96,6 +97,5 @@ module Split
       return metric_name, goals
     end
     private_class_method :normalize_metric
-
   end
 end

data/lib/split/persistence/cookie_adapter.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 require "json"
 
 module Split
   module Persistence
     class CookieAdapter
-
       def initialize(context)
+        @context = context
         @request, @response = context.request, context.response
         @cookies = @request.cookies
         @expires = Time.now + cookie_length_config
@@ -28,20 +29,50 @@ module Split
       end
 
       private
+        def set_cookie(value = {})
+          cookie_key = :split.to_s
+          cookie_value = default_options.merge(value: JSON.generate(value))
+          if action_dispatch?
+            # The "send" is necessary when we call ab_test from the controller
+            # and thus @context is a rails controller, because then "cookies" is
+            # a private method.
+            @context.send(:cookies)[cookie_key] = cookie_value
+          else
+            set_cookie_via_rack(cookie_key, cookie_value)
+          end
+        end
 
-      def set_cookie(value = {})
-        @response.set_cookie :split.to_s, default_options.merge(value: JSON.generate(value))
-      end
+        def default_options
+          { expires: @expires, path: "/", domain: cookie_domain_config }.compact
+        end
 
-      def default_options
-        { expires: @expires, path: '/' }
-      end
+        def set_cookie_via_rack(key, value)
+          headers = @response.respond_to?(:header) ? @response.header : @response.headers
+          delete_cookie_header!(headers, key, value)
+          Rack::Utils.set_cookie_header!(headers, key, value)
+        end
 
-      def hash
-        @hash ||= begin
-          if cookies = @cookies[:split.to_s]
+        # Use Rack::Utils#make_delete_cookie_header after Rack 2.0.0
+        def delete_cookie_header!(header, key, value)
+          cookie_header = header["Set-Cookie"]
+          case cookie_header
+          when nil, ""
+            cookies = []
+          when String
+            cookies = cookie_header.split("\n")
+          when Array
+            cookies = cookie_header
+          end
+
+          cookies.reject! { |cookie| cookie =~ /\A#{Rack::Utils.escape(key)}=/ }
+          header["Set-Cookie"] = cookies.join("\n")
+        end
+
+        def hash
+          @hash ||= if cookies = @cookies[:split.to_s]
             begin
-              JSON.parse(cookies)
+              parsed = JSON.parse(cookies)
+              parsed.is_a?(Hash) ? parsed : {}
             rescue JSON::ParserError
               {}
             end
@@ -49,12 +80,18 @@ module Split
             {}
           end
         end
-      end
 
-      def cookie_length_config
-        Split.configuration.persistence_cookie_length
-      end
+        def cookie_length_config
+          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
     end
   end
 end

data/lib/split/persistence/dual_adapter.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Split
   module Persistence
     class DualAdapter
-      extend Forwardable
-      def_delegators :@adapter, :keys, :[], :[]=, :delete
+      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]
@@ -22,22 +26,59 @@ module Split
           raise "Please configure :logged_out_adapter"
         end
 
-        if logged_in.call(context)
-          @adapter = logged_in_adapter.new(context)
+        @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
-          @adapter = logged_out_adapter.new(context)
+          @active_adapter.keys
         end
       end
 
-      def self.with_config(options={})
-        self.config.merge!(options)
-        self
+      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 self.config
-        @config ||= {}
+      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

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class RedisAdapter
-      DEFAULT_CONFIG = {:namespace => 'persistence'}.freeze
+      DEFAULT_CONFIG = { namespace: "persistence" }.freeze
 
       attr_reader :redis_key
 
@@ -26,7 +27,7 @@ module Split
       end
 
       def []=(field, value)
-        Split.redis.hset(redis_key, field, value)
+        Split.redis.hset(redis_key, field, value.to_s)
         expire_seconds = self.class.config[:expire_seconds]
         Split.redis.expire(redis_key, expire_seconds) if expire_seconds
       end
@@ -39,7 +40,11 @@ module Split
         Split.redis.hkeys(redis_key)
       end
 
-      def self.with_config(options={})
+      def self.find(user_id)
+        new(nil, user_id)
+      end
+
+      def self.with_config(options = {})
         self.config.merge!(options)
         self
       end
@@ -51,7 +56,6 @@ module Split
       def self.reset_config!
         @config = DEFAULT_CONFIG.dup
       end
-
     end
   end
 end

data/lib/split/persistence/session_adapter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class SessionAdapter
-
       def initialize(context)
         @session = context.session
         @session[:split] ||= {}
@@ -23,7 +23,6 @@ module Split
       def keys
         @session[:split].keys
       end
-
     end
   end
 end

data/lib/split/persistence.rb

@@ -2,14 +2,16 @@
 
 module Split
   module Persistence
-    require 'split/persistence/cookie_adapter'
-    require 'split/persistence/dual_adapter'
-    require 'split/persistence/redis_adapter'
-    require 'split/persistence/session_adapter'
+    require "split/persistence/cookie_adapter"
+    require "split/persistence/dual_adapter"
+    require "split/persistence/redis_adapter"
+    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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Split
   # Simplifies the interface to Redis.
   class RedisInterface
@@ -6,46 +8,29 @@ 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"
+          tmp_list += redis_namespace_used? ? "{#{Split.redis.namespace}:#{list_name}}" : "{#{list_name}}"
+          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)
-      while list_length(list_name) > new_length
-        remove_last_item_from_list(list_name)
-      end
+      list_values
     end
 
     def add_to_set(set_name, value)
-      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+      return redis.sadd?(set_name, value) if redis.respond_to?(:sadd?)
+
+      redis.sadd(set_name, value)
     end
 
     private
+      attr_accessor :redis
 
-    attr_accessor :redis
+      def redis_namespace_used?
+        defined?(Redis::Namespace) && Split.redis.is_a?(Redis::Namespace)
+      end
   end
 end