sinmetrics 0.0.7 → 0.0.8

data/lib/sinmetrics/abingo.rb

@@ -42,40 +42,29 @@ module Sinatra
     #A simple convenience method for doing an A/B test.  Returns true or false.
     #If you pass it a block, it will bind the choice to the variable given to the block.
     def flip(test_name)
+      choice = test(test_name, [true, false])
       if block_given?
-        yield(test(test_name, [true, false]))
+        yield choice
       else
-        test(test_name, [true, false])
+        choice
       end
     end
 
     #This is the meat of A/Bingo.
     #options accepts
     #  :multiple_participation (true or false)
-    #  :conversion  name of conversion to listen for  (alias: conversion_name)
+    #  :no_particiation (true or false)
     def test(test_name, alternatives, options = {})
-      short_circuit = cache.read("Abingo::Experiment::short_circuit(#{test_name})".gsub(" ", "_"))
-      unless short_circuit.nil?
-        return short_circuit  #Test has been stopped, pick canonical alternative.
+      experiment = Experiment.get(test_name)
+      experiment ||= Experiment.start_experiment!(self, test_name, parse_alternatives(alternatives))
+
+      # Test has been stopped, pick canonical alternative.
+      unless experiment.short_circuit.nil?
+        return experiment.short_circuit
       end
     
-      unless Experiment.exists?(self, test_name)
-        conversion_name = options[:conversion] || options[:conversion_name]
-        Experiment.start_experiment!(self, test_name, parse_alternatives(alternatives), conversion_name)
-      end
-
       choice = find_alternative_for_user(test_name, alternatives)
-      participating_tests = cache.read("Abingo::participating_tests::#{identity}") || []
-    
-      #Set this user to participate in this experiment, and increment participants count.
-      if options[:multiple_participation] || !(participating_tests.include?(test_name))
-        participating_tests = participating_tests.dup if participating_tests.frozen?
-        unless participating_tests.include?(test_name)
-          participating_tests << test_name
-          cache.write("Abingo::participating_tests::#{identity}", participating_tests)
-        end
-        Alternative.score_participation(self, test_name)
-      end
+      score_participation!(test_name, options) unless options[:no_participation]
 
       if block_given?
         yield(choice)
@@ -87,9 +76,6 @@ module Sinatra
     #Scores conversions for tests.
     #test_name_or_array supports three types of input:
     #
-    #A conversion name: scores a conversion for any test the user is participating in which
-    #  is listening to the specified conversion.
-    #
     #A test name: scores a conversion for the named test if the user is participating in it.
     #
     #An array of either of the above: for each element of the array, process as above.
@@ -107,23 +93,8 @@ module Sinatra
           participating_tests.each do |participating_test|
             self.bingo!(participating_test, options)
           end
-        else #Could be a test name or conversion name.
-          conversion_name = name.gsub(" ", "_")
-          tests_listening_to_conversion = cache.read("Abingo::tests_listening_to_conversion#{conversion_name}")
-          if tests_listening_to_conversion
-            if tests_listening_to_conversion.size > 1
-              tests_listening_to_conversion.map do |individual_test|
-                self.score_conversion!(individual_test.to_s, options)
-              end
-            elsif tests_listening_to_conversion.size == 1
-              test_name_str = tests_listening_to_conversion.first.to_s
-              self.score_conversion!(test_name_str, options)
-            end
-          else
-            #No tests listening for this conversion.  Assume it is just a test name.
-            test_name_str = name.to_s
-            self.score_conversion!(test_name_str, options)
-          end
+        else
+          self.score_conversion!(name.to_s, options)
         end
       end
     end
@@ -164,33 +135,40 @@ module Sinatra
       end
     end
 
-    def retrieve_alternatives(test_name, alternatives)
+    def find_alternative_for_user(test_name, alternatives)
       cache_key = "Abingo::Experiment::#{test_name}::alternatives".gsub(" ","_")
       alternative_array = self.cache.fetch(cache_key) do
         self.parse_alternatives(alternatives)
       end
-      alternative_array
-    end
 
-    def find_alternative_for_user(test_name, alternatives)
-      alternatives_array = retrieve_alternatives(test_name, alternatives)
-      alternatives_array[self.modulo_choice(test_name, alternatives_array.size)]
+      #Quickly determines what alternative to show a given user.  Given a test name
+      #and their identity, we hash them together (which, for MD5, provably introduces
+      #enough entropy that we don't care) otherwise
+      choice = Digest::MD5.hexdigest(salt.to_s + test_name + self.identity.to_s).to_i(16) % alternative_array.size
+      alternative_array[choice]
     end
-
-    #Quickly determines what alternative to show a given user.  Given a test name
-    #and their identity, we hash them together (which, for MD5, provably introduces
-    #enough entropy that we don't care) otherwise
-    def modulo_choice(test_name, choices_count)
-      Digest::MD5.hexdigest(salt.to_s + test_name + self.identity.to_s).to_i(16) % choices_count
+    
+    def alternatives_for_test(test_name)
+      cache_key = "Abingo::Experiment::#{test_name}::alternatives".gsub(" ","_")    
+      self.cache.fetch(cache_key) do
+        Experiment.get(test_name).alternatives.map do |alt| 
+          if alt.weight > 1 
+            [alt.content] * alt.weight
+          else
+            alt.content
+          end
+        end.flatten
+      end
     end
 
     def score_conversion!(test_name, options = {})
-      test_name.gsub!(" ", "_")
       participating_tests = cache.read("Abingo::participating_tests::#{identity}") || []
       if options[:assume_participation] || participating_tests.include?(test_name)
         cache_key = "Abingo::conversions(#{identity},#{test_name}"
         if options[:multiple_conversions] || !cache.read(cache_key)
-          Alternative.score_conversion(self, test_name)
+          viewed_alternative = find_alternative_for_user(test_name, alternatives_for_test(test_name))
+          lookup = calculate_alternative_lookup(test_name, viewed_alternative)
+          Alternative.all(:lookup => lookup).adjust!(:conversions => 1)
           if cache.exist?(cache_key)
             cache.increment(cache_key)
           else
@@ -200,6 +178,23 @@ module Sinatra
       end
     end
     
+    def score_participation!(test_name, options = {})
+      participating_tests = cache.read("Abingo::participating_tests::#{identity}") || []
+    
+      #Set this user to participate in this experiment, and increment participants count.
+      if options[:multiple_participation] || !(participating_tests.include?(test_name))
+        participating_tests = participating_tests.dup if participating_tests.frozen?
+        unless participating_tests.include?(test_name)
+          participating_tests << test_name
+          cache.write("Abingo::participating_tests::#{identity}", participating_tests)
+        end
+        
+        choice = find_alternative_for_user(test_name, alternatives_for_test(test_name))
+        lookup = calculate_alternative_lookup(test_name, choice)
+        Alternative.all(:lookup => lookup).adjust!(:participants => 1)
+      end
+    end
+    
     def end_experiment(alternative_id)
       alternative = Alternative.get(alternative_id)
       experiment = alternative.experiment
@@ -207,6 +202,10 @@ module Sinatra
         experiment.end_experiment!(self, alternative.content)
       end
     end
+    
+    def calculate_alternative_lookup(test_name, alternative_name)
+      Digest::MD5.hexdigest(self.salt + test_name + alternative_name.to_s)
+    end
   end
   
   module AbingoObject::ConversionRate

data/lib/sinmetrics/abingo/alternative.rb

@@ -10,21 +10,4 @@ class Abingo::Alternative
   property :conversions, Integer, :default => 0
 
   belongs_to :experiment
-
-  def self.calculate_lookup(abingo, test_name, alternative_name)
-    Digest::MD5.hexdigest(abingo.salt + test_name + alternative_name.to_s)
-  end
-
-  def self.score_conversion(abingo, test_name)
-    viewed_alternative = abingo.find_alternative_for_user(test_name,
-      Abingo::Experiment.alternatives_for_test(abingo, test_name))
-    all(:lookup => self.calculate_lookup(abingo, test_name, viewed_alternative)).adjust!(:conversions => 1)
-  end
-
-  def self.score_participation(abingo, test_name)
-    viewed_alternative = abingo.find_alternative_for_user(test_name,
-      Abingo::Experiment.alternatives_for_test(abingo, test_name))
-    all(:lookup => self.calculate_lookup(abingo, test_name, viewed_alternative)).adjust!(:participants => 1)
-  end
-
 end

data/lib/sinmetrics/abingo/experiment.rb

@@ -5,6 +5,7 @@ class Abingo::Experiment
 
   property :test_name, String, :key => true
   property :status, String
+  property :short_circuit, String
   
   has n, :alternatives, "Alternative"
 
@@ -37,33 +38,7 @@ class Abingo::Experiment
     end
   end
 
-  def self.exists?(abingo, test_name)
-    cache_key = "Abingo::Experiment::exists(#{test_name})".gsub(" ", "_")
-    ret = abingo.cache.fetch(cache_key) do
-      count = Abingo::Experiment.count(:conditions => {:test_name => test_name})
-      count > 0 ? count : nil
-    end
-    (!ret.nil?)
-  end
-
-  def self.alternatives_for_test(abingo, test_name)
-    cache_key = "Abingo::#{test_name}::alternatives".gsub(" ","_")    
-    abingo.cache.fetch(cache_key) do
-      experiment = Abingo::Experiment.first(:test_name => test_name)      
-      alternatives_array = abingo.cache.fetch(cache_key) do
-        tmp_array = experiment.alternatives.map do |alt|
-          [alt.content, alt.weight]
-        end
-        tmp_hash = tmp_array.inject({}) {|hash, couplet| hash[couplet[0]] = couplet[1]; hash}
-        abingo.parse_alternatives(tmp_hash)
-      end
-      alternatives_array
-    end
-  end
-
-  def self.start_experiment!(abingo, test_name, alternatives_array, conversion_name = nil)
-    conversion_name ||= test_name
-    conversion_name.gsub!(" ", "_")
+  def self.start_experiment!(abingo, test_name, alternatives_array)
     cloned_alternatives_array = alternatives_array.clone
     Abingo::Experiment.transaction do |txn|
       experiment = Abingo::Experiment.first_or_create(:test_name => test_name)
@@ -72,32 +47,22 @@ class Abingo::Experiment
         alt = cloned_alternatives_array[0]
         weight = cloned_alternatives_array.size - (cloned_alternatives_array - [alt]).size
         experiment.alternatives << Abingo::Alternative.new(:content => alt, :weight => weight,
-          :lookup => Abingo::Alternative.calculate_lookup(abingo, test_name, alt))
+          :lookup => abingo.calculate_alternative_lookup(test_name, alt))
         cloned_alternatives_array -= [alt]
       end
       experiment.status = "Live"
       experiment.save
-      abingo.cache.write("Abingo::Experiment::exists(#{test_name})".gsub(" ", "_"), 1)
-
-      #This might have issues in very, very high concurrency environments...
-
-      tests_listening_to_conversion = abingo.cache.read("Abingo::tests_listening_to_conversion#{conversion_name}") || []
-      tests_listening_to_conversion = tests_listening_to_conversion.dup if tests_listening_to_conversion.frozen?
-      tests_listening_to_conversion << test_name unless tests_listening_to_conversion.include? test_name
-      abingo.cache.write("Abingo::tests_listening_to_conversion#{conversion_name}", tests_listening_to_conversion)
       experiment
     end
   end
 
-  def end_experiment!(abingo, final_alternative, conversion_name = nil)
-    conversion_name ||= test_name
+  def end_experiment!(abingo, final_alternative)
     Abingo::Experiment.transaction do
       alternatives.each do |alternative|
         alternative.lookup = "Experiment completed.  #{alternative.id}"
         alternative.save!
       end
-      update(:status => "Finished")
-      abingo.cache.write("Abingo::Experiment::short_circuit(#{test_name})".gsub(" ", "_"), final_alternative)
+      update(:status => "Finished", :short_circuit => final_alternative)
     end
   end
 

data/spec/abingo_spec.rb

@@ -36,6 +36,13 @@ describe 'Abingo Specs' do
     @abingo.parse_alternatives(2..5).should_not include(1)
   end
   
+  it "should parse weighted alternatives" do
+    hash = { 'a' => 2, 'b' => 3, 'c' => 1}
+    array = %w{a a a b b c}
+    @abingo.parse_alternatives(array).should == array
+  end
+  
+  
   it "should create experiments" do
     Abingo::Experiment.count.should == 0
     Abingo::Alternative.count.should == 0
@@ -46,12 +53,6 @@ describe 'Abingo Specs' do
     alternatives.should include(alternative_selected)
   end
   
-  it "should be able to call exists" do
-    @abingo.test("exist words right", %w{does does_not})
-    Abingo::Experiment.exists?(@abingo, "exist words right").should be_true
-    Abingo::Experiment.exists?(@abingo, "other words right").should_not be_true
-  end
-  
   it "should pick alternatives consistently" do
     alternative_picked = @abingo.test("consistency_test", 1..100)
     100.times do
@@ -76,8 +77,8 @@ describe 'Abingo Specs' do
     test_name = "participants_counted_test"
     alternative = @abingo.test(test_name, %w{a b c})
 
-    ex = Abingo::Experiment.first(:test_name => test_name)
-    lookup = Abingo::Alternative.calculate_lookup(@abingo, test_name, alternative)
+    ex = Abingo::Experiment.get(test_name)
+    lookup = @abingo.calculate_alternative_lookup(test_name, alternative)
     chosen_alt = Abingo::Alternative.first(:lookup => lookup)
     ex.participants.should == 1
     chosen_alt.participants.should == 1
@@ -87,8 +88,8 @@ describe 'Abingo Specs' do
     test_name = "conversion_test_by_name"
     alternative = @abingo.test(test_name, %w{a b c})
     @abingo.bingo!(test_name)
-    ex = Abingo::Experiment.first(:test_name => test_name)
-    lookup = Abingo::Alternative.calculate_lookup(@abingo, test_name, alternative)
+    ex = Abingo::Experiment.get(test_name)
+    lookup =  @abingo.calculate_alternative_lookup(test_name, alternative)
     chosen_alt = Abingo::Alternative.first(:lookup => lookup)
     ex.conversions.should == 1
     chosen_alt.conversions.should == 1
@@ -97,40 +98,25 @@ describe 'Abingo Specs' do
 
     #Should still only have one because this conversion should not be double counted.
     #We haven't specified that in the test options.
-    ex = Abingo::Experiment.first(:test_name => test_name)
+    ex = Abingo::Experiment.get(test_name)
     ex.conversions.should == 1
   end
 
   it "should know the best alternative" do
     test_name = "conversion_test_by_name"
-    alternative = @abingo.test(test_name, %w{a b c})
+    alternative = @abingo.test(test_name, {'a' => 3, 'b' => 2, 'c' => 1})
     @abingo.bingo!(test_name)
-    ex = Abingo::Experiment.first(:test_name => test_name)
-    ex.best_alternative
+    ex = Abingo::Experiment.get(test_name)
+    ex.best_alternative.content.should == alternative
   end
   
-  it "should track conversions by conversion name" do
-    conversion_name = "purchase"
-    tests = %w{conversionTrackingByConversionNameA conversionTrackingByConversionNameB conversionTrackingByConversionNameC}
-    tests.map do |test_name|
-      @abingo.test(test_name, %w{A B}, :conversion => conversion_name)
-    end
-
-    @abingo.bingo!(conversion_name)
-    tests.map do |test_name|
-      ex = Abingo::Experiment.first(:test_name => test_name)
-      ex.conversions.should == 1
-    end
-  end
-
   it "should be possible to short circuit tests" do
-    conversion_name = "purchase"
     test_name = "short circuit test"
-    alt_picked = @abingo.test(test_name, %w{A B}, :conversion => conversion_name)
-    ex = Abingo::Experiment.first(:test_name => test_name)
+    alt_picked = @abingo.test(test_name, %w{A B})
+    ex = Abingo::Experiment.get(test_name)
     alt_not_picked = (%w{A B} - [alt_picked]).first
 
-    ex.end_experiment!(@abingo, alt_not_picked, conversion_name)
+    ex.end_experiment!(@abingo, alt_not_picked)
 
     ex.reload
     ex.status.should == "Finished"
@@ -140,7 +126,7 @@ describe 'Abingo Specs' do
 
     old_identity = @abingo.identity
     @abingo.identity = "shortCircuitTestNewIdentity"
-    @abingo.test(test_name, %w{A B}, :conversion => conversion_name)
+    @abingo.test(test_name, %w{A B})
     @abingo.identity = old_identity
     ex.reload
 

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require 'spec'
 require 'sinmetrics'
 
 # establish in-memory database for testing
+#DataMapper::Logger.new($stdout, :debug)
 DataMapper.setup(:default, "sqlite3::memory:")
 
 Spec::Runner.configure do |config|

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sinmetrics
 version: !ruby/object:Gem::Version 
+  hash: 15
   prerelease: false
   segments: 
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Luke Petre
@@ -21,9 +22,11 @@ dependencies:
   name: dm-core
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 51
         segments: 
         - 0
         - 10
@@ -35,9 +38,11 @@ dependencies:
   name: dm-aggregates
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 51
         segments: 
         - 0
         - 10
@@ -49,9 +54,11 @@ dependencies:
   name: dm-observer
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 51
         segments: 
         - 0
         - 10
@@ -63,9 +70,11 @@ dependencies:
   name: dm-timestamps
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 51
         segments: 
         - 0
         - 10
@@ -77,9 +86,11 @@ dependencies:
   name: dm-adjust
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 51
         segments: 
         - 0
         - 10
@@ -91,9 +102,11 @@ dependencies:
   name: activesupport
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 9
         segments: 
         - 2
         - 3
@@ -134,23 +147,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: simple sinatra metrics extension