field_test 0.2.4 → 0.4.1

data/app/controllers/field_test/base_controller.rb

@@ -2,7 +2,7 @@ module FieldTest
   class BaseController < ActionController::Base
     layout "field_test/application"
 
-    protect_from_forgery
+    protect_from_forgery with: :exception
 
     http_basic_authenticate_with name: ENV["FIELD_TEST_USERNAME"], password: ENV["FIELD_TEST_PASSWORD"] if ENV["FIELD_TEST_PASSWORD"]
   end

data/app/controllers/field_test/memberships_controller.rb

@@ -2,8 +2,8 @@ module FieldTest
   class MembershipsController < BaseController
     def update
       membership = FieldTest::Membership.find(params[:id])
-      membership.update_attributes(membership_params)
-      redirect_to participant_path(membership.participant)
+      membership.update!(membership_params)
+      redirect_back(fallback_location: root_path)
     end
 
     private

data/app/controllers/field_test/participants_controller.rb

@@ -1,9 +1,17 @@
 module FieldTest
   class ParticipantsController < BaseController
     def show
-      @participant = params[:id]
       # TODO better ordering
-      @memberships = FieldTest::Membership.where(participant: @participant).order(:id)
+      @memberships =
+        if FieldTest.legacy_participants
+          @participant = params[:id]
+          FieldTest::Membership.where(participant: @participant).order(:id)
+        else
+          id = params[:id]
+          type = params[:type]
+          @participant = [type, id].compact.join(" ")
+          FieldTest::Membership.where(participant_type: type, participant_id: id).order(:id)
+        end
 
       @events =
         if FieldTest.events_supported?

data/app/helpers/field_test/base_helper.rb

@@ -0,0 +1,12 @@
+module FieldTest
+  module BaseHelper
+    def field_test_participant_link(membership)
+      if FieldTest.legacy_participants
+        link_to membership.participant, legacy_participant_path(membership.participant)
+      else
+        text = [membership.participant_type, membership.participant_id].compact.join(" ")
+        link_to text, participant_path(type: membership.participant_type, id: membership.participant_id)
+      end
+    end
+  end
+end

data/app/models/field_test/membership.rb

@@ -4,7 +4,8 @@ module FieldTest
 
     has_many :events, class_name: "FieldTest::Event"
 
-    validates :participant, presence: true
+    validates :participant, presence: true, if: -> { FieldTest.legacy_participants }
+    validates :participant_id, presence: true, if: -> { !FieldTest.legacy_participants }
     validates :experiment, presence: true
     validates :variant, presence: true
   end

data/app/views/field_test/experiments/_experiments.html.erb

@@ -1,6 +1,7 @@
 <% experiments.each do |experiment| %>
   <h2>
     <%= experiment.name %>
+    <% if experiment.active? && experiment.closed? %><small class="closed">Closed</small><% end %>
     <small><%= link_to "Details", experiment_path(experiment.id) %></small>
   </h2>
 
@@ -38,7 +39,7 @@
             <td><%= result[:converted] %></td>
             <td>
               <% if result[:conversion_rate] %>
-                <%= (100.0 * result[:conversion_rate]).round %>%
+                <%= (100.0 * result[:conversion_rate]).round(FieldTest.precision) %>%
               <% else %>
                 -
               <% end %>
@@ -48,7 +49,7 @@
                 <% if result[:prob_winning] < 0.01 %>
                   &lt; 1%
                 <% else %>
-                  <%= (100.0 * result[:prob_winning]).round %>%
+                  <%= (100.0 * result[:prob_winning]).round(FieldTest.precision) %>%
                 <% end %>
               <% end %>
             </td>

data/app/views/field_test/experiments/show.html.erb

@@ -22,7 +22,7 @@
   <tbody>
     <% @memberships.each do |membership| %>
       <tr>
-        <td><%= link_to membership.participant, participant_path(membership.participant) %></td>
+        <td><%= field_test_participant_link(membership) %></td>
         <td><%= membership.variant %></td>
         <td>
           <% converted = false %>

data/app/views/layouts/field_test/application.html.erb

@@ -66,6 +66,10 @@
         color: #5cb85c;
       }
 
+      .closed {
+        color: orange;
+      }
+
       .pagination {
         text-align: center;
       }

data/config/routes.rb

@@ -1,6 +1,7 @@
 FieldTest::Engine.routes.draw do
   resources :experiments, only: [:show]
   resources :memberships, only: [:update]
-  get "participants/:id", to: "participants#show", constraints: {id: /.+/}, as: :participant
+  get "participants/:id", to: "participants#show", constraints: {id: /.+/}, as: :legacy_participant
+  get "participants", to: "participants#show", as: :participant
   root "experiments#index"
 end

data/lib/field_test.rb

@@ -1,26 +1,40 @@
-require "browser"
+# dependencies
 require "active_support"
+require "browser"
+require "ipaddr"
+
+# modules
 require "field_test/calculations"
 require "field_test/experiment"
-require "field_test/engine" if defined?(Rails)
 require "field_test/helpers"
 require "field_test/participant"
 require "field_test/version"
 
+# integrations
+require "field_test/engine" if defined?(Rails)
+
 module FieldTest
   class Error < StandardError; end
   class ExperimentNotFound < Error; end
   class UnknownParticipant < Error; end
 
+  # same as ahoy
+  UUID_NAMESPACE = "a82ae811-5011-45ab-a728-569df7499c5f"
+
+  def self.config_path
+    path = defined?(Rails) ? Rails.root : File
+    path.join("config", "field_test.yml")
+  end
+
   def self.config
-    # reload in dev
-    @config = nil if Rails.env.development?
+    @config ||= YAML.load(ERB.new(File.read(config_path)).result)
+  end
 
-    @config ||= YAML.load(ERB.new(File.read("config/field_test.yml")).result)
+  def self.excluded_ips
+    @excluded_ips ||= Array(config["exclude"] && config["exclude"]["ips"]).map { |ip| IPAddr.new(ip) }
   end
 
   def self.exclude_bots?
-    config = self.config # dev performance
     config["exclude"] && config["exclude"]["bots"]
   end
 
@@ -28,6 +42,18 @@ module FieldTest
     config["cache"]
   end
 
+  def self.cookies
+    config.key?("cookies") ? config["cookies"] : true
+  end
+
+  def self.legacy_participants
+    config["legacy_participants"]
+  end
+
+  def self.precision
+    config["precision"] || 0
+  end
+
   def self.events_supported?
     unless defined?(@events_supported)
       connection = FieldTest::Membership.connection
@@ -41,16 +67,25 @@ module FieldTest
     end
     @events_supported
   end
-end
 
-ActiveSupport.on_load(:action_controller) do
-  include FieldTest::Helpers
+  def self.mask_ip(ip)
+    addr = IPAddr.new(ip)
+    if addr.ipv4?
+      # set last octet to 0
+      addr.mask(24).to_s
+    else
+      # set last 80 bits to zeros
+      addr.mask(48).to_s
+    end
+  end
 end
 
-ActiveSupport.on_load(:action_view) do
-  include FieldTest::Helpers
+ActiveSupport.on_load(:action_controller) do
+  require "field_test/controller"
+  include FieldTest::Controller
 end
 
 ActiveSupport.on_load(:action_mailer) do
-  include FieldTest::Helpers
+  require "field_test/mailer"
+  include FieldTest::Mailer
 end

data/lib/field_test/controller.rb

@@ -0,0 +1,76 @@
+module FieldTest
+  module Controller
+    extend ActiveSupport::Concern
+    include Helpers
+
+    included do
+      if respond_to?(:helper_method)
+        helper_method :field_test
+        helper_method :field_test_converted
+        helper_method :field_test_experiments
+      end
+    end
+
+    def field_test_upgrade_memberships(options = {})
+      participants = FieldTest::Participant.standardize(options[:participant] || field_test_participant)
+      preferred = participants.first
+      Array(participants[1..-1]).each do |participant|
+        # can do this in single query once legacy_participants is removed
+        FieldTest::Membership.where(participant.where_values).each do |membership|
+          membership.participant = preferred.participant if membership.respond_to?(:participant=)
+          membership.participant_type = preferred.type if membership.respond_to?(:participant_type=)
+          membership.participant_id = preferred.id if membership.respond_to?(:participant_id=)
+          membership.save!
+        end
+      end
+    end
+
+    private
+
+    def field_test_participant
+      participants = []
+
+      if respond_to?(:current_user, true)
+        user = send(:current_user)
+        participants << user if user
+      end
+
+      cookie_key = "field_test"
+
+      # name not entirely accurate
+      # can still set cookies in ActionController::API through request.cookie_jar
+      # however, best to prompt developer to pass participant manually
+      cookies_supported = respond_to?(:cookies, true)
+
+      if request.headers["Field-Test-Visitor"]
+        token = request.headers["Field-Test-Visitor"]
+      elsif FieldTest.cookies && cookies_supported
+        token = cookies[cookie_key]
+
+        if participants.empty? && !token
+          token = SecureRandom.uuid
+          cookies[cookie_key] = {value: token, expires: 30.days.from_now}
+        end
+      elsif !FieldTest.cookies
+        # anonymity set
+        # note: hashing does not conceal input
+        token = Digest::UUID.uuid_v5(FieldTest::UUID_NAMESPACE, ["visitor", FieldTest.mask_ip(request.remote_ip), request.user_agent].join("/"))
+
+        # delete cookie if present
+        cookies.delete(cookie_key) if cookies_supported && cookies[cookie_key]
+      end
+
+      # sanitize tokens
+      token = token.gsub(/[^a-z0-9\-]/i, "") if token
+
+      if token.present?
+        participants << token
+
+        # backwards compatibility
+        participants << "cookie:#{token}" if FieldTest.legacy_participants
+      end
+
+      participants
+    end
+  end
+end

data/lib/field_test/experiment.rb

@@ -10,52 +10,54 @@ module FieldTest
       @variants = attributes[:variants]
       @weights = @variants.size.times.map { |i| attributes[:weights].to_a[i] || 1 }
       @winner = attributes[:winner]
+      @closed = attributes[:closed]
+      @keep_variant = attributes[:keep_variant]
       @started_at = Time.zone.parse(attributes[:started_at].to_s) if attributes[:started_at]
       @ended_at = Time.zone.parse(attributes[:ended_at].to_s) if attributes[:ended_at]
       @goals = attributes[:goals] || ["conversion"]
+      @goals_defined = !attributes[:goals].nil?
       @use_events = attributes[:use_events]
     end
 
     def variant(participants, options = {})
-      return winner if winner
-      return variants.first if options[:exclude]
+      return winner if winner && !keep_variant?
+      return control if options[:exclude]
 
       participants = FieldTest::Participant.standardize(participants)
       check_participants(participants)
       membership = membership_for(participants) || FieldTest::Membership.new(experiment: id)
 
+      if winner # and keep_variant?
+        return membership.variant || winner
+      end
+
       if options[:variant] && variants.include?(options[:variant])
         membership.variant = options[:variant]
       else
-        membership.variant ||= weighted_variant
+        membership.variant ||= closed? ? control : weighted_variant
       end
 
+      participant = participants.first
+
       # upgrade to preferred participant
-      membership.participant = participants.first
+      membership.participant = participant.participant if membership.respond_to?(:participant=)
+      membership.participant_type = participant.type if membership.respond_to?(:participant_type=)
+      membership.participant_id = participant.id if membership.respond_to?(:participant_id=)
 
-      if membership.changed?
+      if membership.changed? && (!closed? || membership.persisted?)
         begin
           membership.save!
-
-          # log it!
-          info = {
-            experiment: id,
-            variant: membership.variant,
-            participant: membership.participant
-          }.merge(options.slice(:ip, :user_agent))
-
-          # sorta logfmt :)
-          info = info.map { |k, v| v = "\"#{v}\"" if k == :user_agent; "#{k}=#{v}" }.join(" ")
-          Rails.logger.info "[field test] #{info}"
         rescue ActiveRecord::RecordNotUnique
-          membership = memberships.find_by(participant: participants.first)
+          membership = memberships.find_by(participant.where_values)
         end
       end
 
-      membership.try(:variant) || variants.first
+      membership.try(:variant) || control
     end
 
     def convert(participants, goal: nil)
+      return false if winner
+
       goal ||= goals.first
 
       participants = FieldTest::Participant.standardize(participants)
@@ -100,16 +102,29 @@ module FieldTest
       relation = relation.where("field_test_memberships.created_at >= ?", started_at) if started_at
       relation = relation.where("field_test_memberships.created_at <= ?", ended_at) if ended_at
 
-      if use_events?
+      if use_events? && @goals_defined
         data = {}
-        sql =
-          relation.joins("LEFT JOIN field_test_events ON field_test_events.field_test_membership_id = field_test_memberships.id")
-            .select("variant, COUNT(DISTINCT participant) AS participated, COUNT(DISTINCT field_test_membership_id) AS converted")
-            .where(field_test_events: {name: [goal, nil]})
-
-        FieldTest::Membership.connection.select_all(sql).each do |row|
-          data[[row["variant"], true]] = row["converted"].to_i
-          data[[row["variant"], false]] = row["participated"].to_i - row["converted"].to_i
+
+        participated = relation.count
+
+        adapter_name = relation.connection.adapter_name
+        column =
+          if FieldTest.legacy_participants
+            :participant
+          elsif adapter_name =~ /postg/i # postgres
+            "(participant_type, participant_id)"
+          elsif adapter_name =~ /mysql/i
+            "participant_type, participant_id"
+          else
+            # not perfect, but it'll do
+            "COALESCE(participant_type, '') || ':' || participant_id"
+          end
+
+        converted = events.merge(relation).where(field_test_events: {name: goal}).distinct.count(column)
+
+        (participated.keys + converted.keys).uniq.each do |variant|
+          data[[variant, true]] = converted[variant].to_i
+          data[[variant, false]] = participated[variant].to_i - converted[variant].to_i
         end
       else
         data = relation.group(:converted).count
@@ -125,6 +140,7 @@ module FieldTest
           conversion_rate: participated > 0 ? converted.to_f / participated : nil
         }
       end
+
       case variants.size
       when 1, 2, 3
         total = 0.0
@@ -166,6 +182,18 @@ module FieldTest
       !winner
     end
 
+    def closed?
+      @closed
+    end
+
+    def keep_variant?
+      @keep_variant
+    end
+
+    def control
+      variants.first
+    end
+
     def use_events?
       if @use_events.nil?
         FieldTest.events_supported?
@@ -189,32 +217,37 @@ module FieldTest
 
     private
 
-      def check_participants(participants)
-        raise FieldTest::UnknownParticipant, "Use the :participant option to specify a participant" if participants.empty?
-      end
+    def check_participants(participants)
+      raise FieldTest::UnknownParticipant, "Use the :participant option to specify a participant" if participants.empty?
+    end
 
-      def membership_for(participants)
-        memberships = self.memberships.where(participant: participants).index_by(&:participant)
-        participants.map { |part| memberships[part] }.compact.first
+    # TODO fetch in single query
+    def membership_for(participants)
+      membership = nil
+      participants.each do |participant|
+        membership = self.memberships.find_by(participant.where_values)
+        break if membership
       end
+      membership
+    end
 
-      def weighted_variant
-        total = weights.sum.to_f
-        pick = rand
-        n = 0
-        weights.map { |w| w / total }.each_with_index do |w, i|
-          n += w
-          return variants[i] if n >= pick
-        end
-        variants.last
+    def weighted_variant
+      total = weights.sum.to_f
+      pick = rand
+      n = 0
+      weights.map { |w| w / total }.each_with_index do |w, i|
+        n += w
+        return variants[i] if n >= pick
       end
+      variants.last
+    end
 
-      def cache_fetch(key)
-        if FieldTest.cache
-          Rails.cache.fetch(key.join("/")) { yield }
-        else
-          yield
-        end
+    def cache_fetch(key)
+      if FieldTest.cache
+        Rails.cache.fetch(key.join("/")) { yield }
+      else
+        yield
       end
+    end
   end
 end