conductor 0.4.1 → 0.5.0

data/Rakefile

@@ -52,3 +52,4 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.5.0

data/lib/conductor.rb

@@ -34,15 +34,12 @@ class Conductor
     def log(msg)
       puts msg if DBG
     end
+    
+    def sanitize(str)
+      str.gsub(/\s/,'_').downcase
+    end
   end
   
-  # class Rails
-  #    cattr_writer :cache
-  # 
-  #    def self.cache
-  #      []
-  #    end
-  #  end
 end
 
 

data/lib/conductor/controller/dashboard.rb

@@ -0,0 +1,15 @@
+class Conductor
+  module Controller
+    module Dashboard
+
+      ActionController::Base.view_paths.unshift File.join(File.dirname(__FILE__), "../views")
+      
+      def index
+        @weights = Conductor::Experiment::Weight.all
+        @weight_history = Conductor::Experiment::History.all
+        @dailies = Conductor::Experiment::Daily.all
+      end
+      
+    end
+  end
+end

data/lib/conductor/experiment.rb

@@ -19,7 +19,7 @@ class Conductor
       # specific goal.
       #
       def pick(group_name, alternatives, options={})
-        group_name = sanitize(group_name) # => clean up and standardize
+        group_name = Conductor.sanitize(group_name) # => clean up and standardize
 
         # check for previous selection
         selection = Conductor.cache.read("Conductor::#{Conductor.identity}::Experience::#{group_name}")
@@ -35,7 +35,7 @@ class Conductor
 
       # returns the raw weighting table for all alternatives for a specified group
       def weights(group_name, alternatives)
-        group_name = sanitize(group_name) # => clean up and standardize
+        group_name = Conductor.sanitize(group_name) # => clean up and standardize
         return generate_weighting_table(group_name, alternatives)
       end
 
@@ -94,14 +94,8 @@ class Conductor
         # those not in the alternatives list
         #
         def generate_weighting_table(group_name, alternatives)
-          # create the conditions after sanitizing sql.
-          alternative_filter = alternatives.inject([]) {|res,x| res << "alternative = '#{sanitize(x)}'"}.join(' OR ')
-
-          conditions = "group_name = '#{group_name}' AND (#{alternative_filter})"
-
-          # get the alternatives from the database
-          weights ||= Conductor::Experiment::Weight.find(:all, :conditions => conditions)
-
+          weights = Conductor::Weights.find_or_create(group_name, alternatives)
+          
           # create selection hash
           weighting_table = weights.inject({}) {|res, x| res.merge!({x.alternative => x.weight})}
 
@@ -119,7 +113,7 @@ class Conductor
 
           return weighting_table
         end
-
+        
         # selects a random float
         def float_rand(start_num, end_num=0)
           width = end_num-start_num
@@ -146,11 +140,6 @@ class Conductor
           sum = sum.to_f
           weighted.each { |item, weight| weighted[item] = weight/sum }
         end
-
-        def sanitize(str)
-          str.gsub(/\s/,'_').downcase
-        end
-
     end
   end
 end

data/lib/conductor/experiment/daily.rb

@@ -14,4 +14,6 @@
 class Conductor::Experiment::Daily < ActiveRecord::Base
   set_table_name "conductor_daily_experiments"
   named_scope :since, lambda { |a_date| { :conditions =>  ['activity_date >= ?',a_date] }}
+  named_scope :for_group, lambda { |group_name| { :conditions =>  ['group_name = ?',group_name] }}
+  
 end

data/lib/conductor/roll_up.rb

@@ -12,12 +12,15 @@ class Conductor
             views = alternatives.count
             conversions = alternatives.count {|x| !x.conversion_value.nil?}
             Conductor::Experiment::Daily.create!(:activity_date => day,
-                                         :group_name => group_name,
-                                         :alternative => alternative_name,
-                                         :conversion_value => conversion_value,
-                                         :views => views,
-                                         :conversions => conversions )
+                                                 :group_name => group_name,
+                                                 :alternative => alternative_name,
+                                                 :conversion_value => conversion_value,
+                                                 :views => views,
+                                                 :conversions => conversions )
           end
+          
+          # delete the cache for this group so it can be recreated with the new values
+          Conductor.cache.delete("Conductor::Experiment::#{group_name}::Alternatives")
         end
       end
     end

data/lib/conductor/views/index.html.haml

@@ -0,0 +1,33 @@
+#conductor_dashboard
+  #weights
+    - @weights.group_by(&:group_name).each do |group_name, group|
+    .group
+      %fieldset
+        %legend= group_name
+        = group.each do |row|
+          .name= row.alternative
+          .weight= row.weight
+          
+  #dailies
+    - @dailies.group_by(&:group_name).each do |group_name, group|
+      .group
+        %fieldset
+          %legend= group_name
+          = group.sort_by(&:activity_date).each do |row|
+            .date= row.activity_date
+            .name= row.alternative
+            .views= row.views
+            .conversions= row.conversions
+            .value= row.conversion_value
+            
+  #history
+    - @weight_history.group_by(&:group_name).each do |group_name, group|
+      .group
+        %fieldset
+          %legend= group_name
+          = group.sort_by(&:computed_at).reverse.each do |row|
+            .date= row.computed_at
+            .name= row.alternative
+            .weight= row.weight
+            
+              

data/lib/conductor/weights.rb

@@ -1,11 +1,38 @@
 class Conductor
   class Weights
     class << self
-      def compute
-        Conductor::Experiment::Weight.delete_all # => remove all old data
 
-        # loop through each group and determing weight of alternatives
-        Conductor::Experiment::Daily.since(14.days.ago).group_by(&:group_name).each do |group_name, group_rows|
+      # Returns all the weights for a given group.  In the event that the alternatives specified for the
+      # group do not match all the alternatives previously computed for the group, new weights are
+      # generated.  The cache is used to speed up this check
+      def find_or_create(group_name, alternatives)
+        weights_for_group = Conductor.cache.read("Conductor::Experiment::#{group_name}::Alternatives")
+
+        alternatives_array = weights_for_group.map(&:alternative).sort if weights_for_group
+        if alternatives_array.eql?(alternatives.sort)
+          Conductor.log('alternatives equal to cache')
+          return weights_for_group
+        else
+          # Conductor.log('alternatives NOT equal to cache.  Need to recompute')
+          compute(group_name, alternatives)
+
+          # get the new weights
+          weights_for_group = Conductor::Experiment::Weight.find(:all, :conditions => "group_name = '#{group_name}'")
+          Conductor.cache.delete("Conductor::Experiment::#{group_name}::Alternatives")
+          Conductor.cache.write("Conductor::Experiment::#{group_name}::Alternatives", weights_for_group)
+          return weights_for_group
+        end
+      end
+
+      def compute(group_name, alternatives)
+        # create the conditions after sanitizing sql.
+        alternative_filter = alternatives.inject([]) {|res,x| res << "alternative = '#{Conductor.sanitize(x)}'"}.join(' OR ')
+
+        # pull daily data and recompute if daily data
+        group_rows = Conductor::Experiment::Daily.since(14.days.ago).for_group(group_name).find(:all, :conditions => alternative_filter)
+
+        unless group_rows.empty?
+          Conductor::Experiment::Weight.delete_all(:group_name => group_name) # => remove all old data for group
           total = group_rows.sum_it(:conversion_value)
           data = total ? compute_weights_for_group(group_name, group_rows, total) : assign_equal_weights(group_rows)
           update_weights_in_db(group_name, data)
@@ -17,8 +44,6 @@ class Conductor
         # loops through all the alternatives for a given group and computes the weights for
         # each alternative
         def compute_weights_for_group(group_name, group_rows, total)
-          Conductor.log('compute_weights_for_group')
-
           data = []
           recently_launched = []
           max_weight = 0

data/test/test_conductor.rb

@@ -17,6 +17,12 @@ class TestConductor < Test::Unit::TestCase
       assert ["a", "b", "c"].include? selected
     end
 
+    should "use the cache if working" do
+      Conductor.cache.write('testing','value')
+      x = Conductor.cache.read('testing')
+      assert_equal x, 'value'
+    end
+
     should "almost equally select each option if no weights exist" do
       a = 0
       b = 0
@@ -109,6 +115,7 @@ class TestConductor < Test::Unit::TestCase
     setup do
       seed_raw_data(100)
       Conductor::RollUp.process
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)
     end
 
     should "correctly RollUp daily data" do
@@ -117,9 +124,39 @@ class TestConductor < Test::Unit::TestCase
       assert Conductor::Experiment::Daily.all.detect {|x| x.views > 0}
       assert Conductor::Experiment::Daily.all.detect {|x| x.conversion_value > 0}
     end
+    
+    should "correctly populate weighting table when selecting a value" do
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      assert_equal 3, Conductor::Experiment::Weight.count
+    end
+
+    should "pull weights from the cache" do
+      Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      
+      (1..100).each do |x|
+        Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+        Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      end
+      
+      # => if this works the history table should have only been updated one time not 101 so there should 
+      # => be three records (one for a, b and c)
+      assert_equal 3, Conductor::Experiment::History.count
+    end
+    
+    should "pull weights from the cache and then recreate weights when the alternative list changes" do
+      Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      
+      (1..100).each do |x|
+        Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+        Conductor::Experiment.pick('a_group', ["a", "b", "c"])
+      end
 
-    should "correctly populate weighting table" do
-      Conductor::Weights.compute
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)      
+      Conductor::Experiment.pick('a_group', ["a", "c"])
+      
+      # => if this works the history table should have only been updated one time not 101 so there should 
+      # => be FIVE records (one for a, b and c and then one for a and c)
+      assert_equal 5, Conductor::Experiment::History.count
     end
   end
 
@@ -130,8 +167,9 @@ class TestConductor < Test::Unit::TestCase
       # rollup
       Conductor::RollUp.process
 
-      # compute weights
-      Conductor::Weights.compute
+      # hit after rollup to populare weight table
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"])
 
       # this makes the following assumptions:
       # MINIMUM_LAUNCH_DAYS = 7
@@ -147,8 +185,9 @@ class TestConductor < Test::Unit::TestCase
       # rollup
       Conductor::RollUp.process
 
-      # compute weights
-      Conductor::Weights.compute
+      # hit after rollup to populare weight table
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"])
     end
 
     should "populate the weighting table with different weights" do
@@ -161,14 +200,6 @@ class TestConductor < Test::Unit::TestCase
     end
 
     should "return a weight 1.25 times higher than the highest weight for a newly launched and non-recorded alernative" do
-      seed_raw_data(100, 14)
-
-      # rollup
-      Conductor::RollUp.process
-
-      # compute weights
-      Conductor::Weights.compute
-
       # get the highest weight
       max_weight = Conductor::Experiment::Weight.maximum(:weight)
 
@@ -186,8 +217,9 @@ class TestConductor < Test::Unit::TestCase
       # rollup
       Conductor::RollUp.process
 
-      # compute weights
-      Conductor::Weights.compute
+      # hit after rollup to populare weight table
+      Conductor.identity = ActiveSupport::SecureRandom.hex(16)
+      selected = Conductor::Experiment.pick('a_group', ["a", "b", "c"])
 
       # make sure that launch_window values can be detected
       assert_not_nil Conductor::Experiment::History.find(:all, :conditions => 'launch_window > 0')
@@ -195,8 +227,6 @@ class TestConductor < Test::Unit::TestCase
   end
 
 
-
-
   private
 
     def wipe

data/test/test_helper.rb

@@ -17,7 +17,7 @@ require File.dirname(__FILE__) + '/../init.rb'
 
 
 config = YAML::load(IO.read(File.dirname(__FILE__) + '/db/database.yml'))
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+# ActiveRecord::Base.logger = Logger.new(STDOUT) # Logger.new(File.dirname(__FILE__) + "/debug.log")
 ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'postgresql'])
 ActiveRecord::Migration.verbose = false
 load(File.dirname(__FILE__) + "/db/schema.rb")

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 1
-  version: 0.4.1
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Noctivity
@@ -36,12 +36,14 @@ files:
 - generators/conductor_migration/templates/migration.rb
 - init.rb
 - lib/conductor.rb
+- lib/conductor/controller/dashboard.rb
 - lib/conductor/experiment.rb
 - lib/conductor/experiment/daily.rb
 - lib/conductor/experiment/history.rb
 - lib/conductor/experiment/raw.rb
 - lib/conductor/experiment/weight.rb
 - lib/conductor/roll_up.rb
+- lib/conductor/views/index.html.haml
 - lib/conductor/weights.rb
 - test/db/schema.rb
 - test/test_conductor.rb