mountain-goat 0.1.8 → 1.0.0

data/lib/mountain-goat/controllers/mg/mg.rb

@@ -0,0 +1,47 @@
+
+class Mg < ActionController::Base
+  
+  layout 'mountain_goat'
+  
+  before_filter :verify_access
+  
+  self.prepend_view_path File.join([File.dirname(__FILE__), '../../views/mountain_goat/'])
+  
+  private
+  
+  def store_location(url = nil)
+    if url.nil?
+      if request.method == :post && request.params.count > 0
+        session[:mg_return_to] = "#{request.request_uri}?" + encode_parameters(request.params)
+      else
+        session[:mg_return_to] = request.request_uri
+      end
+    else
+      session[:mg_return_to] = url
+    end
+    
+    logger.warn "Storing location: #{session[:mg_return_to]}"
+  end
+  
+  def redirect_back_or_default(default)
+    redirect_to(session[:mg_return_to] || default)
+    session[:mg_return_to] = nil
+  end
+  
+  def verify_access
+    return if session[:mg_access] == true
+    store_location
+    redirect_to mg_login_url and return
+  end
+  
+  def self.password_digest(password, salt)
+    site_key = '1e9532ea39233e1e2786d80fde90d708c0918d2d'
+    stretches = 10
+    digest = site_key
+    stretches.times do
+      digest = secure_digest(digest, salt, password, site_key)
+    end
+    digest
+  end
+  
+end

data/lib/mountain-goat/controllers/{mountain_goat → mg}/mountain_goat_controller.rb

@@ -1,15 +1,14 @@
 
-class MountainGoatController < ActionController::Base
-  
-  layout 'mountain_goat'
+class Mg::MountainGoatController < Mg
   
   before_filter :verify_access, :except => [ :login, :login_create, :fetch ] 
-  
-  self.prepend_view_path File.join([File.dirname(__FILE__), '../../views/mountain_goat/'])
     
   def fetch
     ct = { :png => 'image/png', :css => 'text/css', :html => 'text/html', :js => 'text/javascript' }
     
+    raise ArgumentError, "Invalid fetch file" if params[:file].match(/(([_][_])|([^a-z0-9_]))/ix) #extra security
+    
+    #We will only serve files located in the public directory for security reasons
     Dir.open(File.join([File.dirname(__FILE__), '../../public/'])).each do |file|
       if file == params[:file].gsub('_','.')
         if file =~ /[.]([a-z0-9]+)$/
@@ -21,13 +20,7 @@ class MountainGoatController < ActionController::Base
       end
     end
     
-    render :file => "#{Rails.root}/public/404.html", :status => :not_found
-  end
-  
-  def verify_access
-    return if session.has_key?(:mg_access) && session[:mg_access] == true
-    store_location
-    redirect_to '/mg/login' and return
+    render :file => "#{RAILS_ROOT}/public/404.html", :status => :not_found
   end
   
   def login
@@ -70,34 +63,4 @@ class MountainGoatController < ActionController::Base
     end
   end
   
-  def store_location(url = nil)
-    if url.nil?
-      if request.method == :post && request.params.count > 0
-        session[:mg_return_to] = "#{request.request_uri}?" + encode_parameters(request.params)
-      else
-        session[:mg_return_to] = request.request_uri
-      end
-    else
-      session[:mg_return_to] = url
-    end
-    
-    logger.warn "Storing location: #{session[:mg_return_to]}"
-  end
-  
-  def redirect_back_or_default(default)
-    redirect_to(session[:mg_return_to] || default)
-    session[:mg_return_to] = nil
-  end
-  
-  private
-  
-  def self.password_digest(password, salt)
-    site_key = '1e9532ea39233e1e2786d80fde90d708c0918d2d'
-    stretches = 10
-    digest = site_key
-    stretches.times do
-      digest = secure_digest(digest, salt, password, site_key)
-    end
-    digest
-  end
 end

data/lib/mountain-goat/controllers/mg/playground_controller.rb

@@ -0,0 +1,8 @@
+
+class Mg::PlaygroundController < Mg
+  
+  def test
+    
+  end
+  
+end

data/lib/mountain-goat/controllers/{mountain_goat/mountain_goat_rallies_controller.rb → mg/rallies_controller.rb}

@@ -1,9 +1,9 @@
-class MountainGoatRalliesController < MountainGoatController
+
+class Mg::RalliesController < Mg
  
   def index
-     
     @page = !params[:page].nil? ? params[:page].to_i : 1
-    @convert = Convert.find(params[:mountain_goat_convert_id]) if !params[:mountain_goat_convert_id].nil?
+    @convert = Convert.find(params[:convert_id]) if !params[:convert_id].nil?
  
     if @convert
       @rallies = @convert.rallies.find(:all, :conditions => { }, :order => "created_at DESC", :limit => 100, :offset => ( @page - 1 ) * 100 )
@@ -28,7 +28,7 @@ class MountainGoatRalliesController < MountainGoatController
     
     if @rallies.count > 0
       render :json => { :success => true,
-                      :result => render_to_string(:partial => 'mountain_goat_rallies/rallies', :locals => { :rallies => @rallies } ),
+                      :result => render_to_string(:partial => 'mg/rallies/rallies', :locals => { :rallies => @rallies } ),
                       :recent_rally_id => @rallies.first.id }
     else
       render :json => { :success => false }
@@ -40,26 +40,4 @@ class MountainGoatRalliesController < MountainGoatController
     @rally = Rally.find(params[:id])
   end
   
-  def new
-    if params[:convert_id]
-      @rally = Rally.new(:convert_id => params[:convert_id])
-    else
-      @rally = Rally.new
-    end
-    
-  end
-  
-  def create
-    
-  end
-  
-  def edit
-    @rally = Rally.find(params[:id])  
-  end
-  
-  def update
-    
-  end
-  
-  
 end

data/lib/mountain-goat/controllers/mg/report_items_controller.rb

@@ -0,0 +1,82 @@
+class Mg::ReportItemsController < Mg
+  
+  def get_extra
+    ( render :json => { :success => true, :result => "<span></span>" } and return ) if params[:value].blank?
+    id, model = params[:value].split('-')
+    reportable = model.constantize.find(id)
+    render :json => { :success => true, :result => render_to_string( :partial => 'mg/report_items/report_item_pivot_form', :locals => { :reportable => reportable } ) }
+  end
+  
+  def new
+    @report = Mg::Report.find(params[:report_id])
+    raise ArgumentError, "Invalid report" if @report.nil?
+    
+    @report_item = Mg::ReportItem.new
+    
+    render :json => { :success => true,
+                        :result => render_to_string(:action => :new, :layout => 'xhr') }
+  end
+  
+  def create
+    @report = Mg::Report.find(params[:report_id])
+    raise ArgumentError, "Invalid report" if @report.nil?
+    
+    @report_item = @report.report_items.new(params[:report_item].clone.delete_if { |k, v| k.intern == :reportable || k.intern == :pivot } )
+    @report_item.order = @report.report_items.to_a.map { |ri| ri.order }.push(0).max + 1#@report.report_items.maximum(:order) + 1 -- weird sqlite3 bugs
+    
+    if !params[:report_item][:reportable].blank?
+      id, model = params[:report_item][:reportable].split('-')
+      @report_item.reportable = model.constantize.find(id)
+    end
+    
+    if !params[:report_item][:pivot].blank?
+      id, model = params[:report_item][:pivot].split('-')
+      @report_item.pivot = model.constantize.find(id)
+    end
+    
+    if @report_item.save
+      render :json => { :success => true,
+                        :close_dialog => true,
+                        :result => "<span>Successfully added report item</span>",
+                        :also => [ { :item => ".report-report-items", :result => render_to_string( :partial => "mg/reports/report_report_items", :locals => { :report => @report_item.report } ) } ] }
+    else
+      render :json => { :success => true,
+                        :result => render_to_string(:action => :new, :layout => 'xhr') }
+    end
+  end
+  
+  def edit
+    @report_item = Mg::ReportItem.find(params[:id])
+    @report = @report_item.report
+    
+    render :json => { :success => true,
+                        :result => render_to_string(:action => :edit, :layout => 'xhr') }
+  end
+  
+  def update
+    @report_item = Mg::ReportItem.find(params[:id])
+    @report_item.update_attributes(params[:report_item].clone.delete_if { |k, v| k.intern == :reportable || k.intern == :pivot } )
+    
+    if !params[:report_item][:reportable].blank?
+      id, model = params[:report_item][:reportable].split('-')
+      @report_item.reportable = model.constantize.find(id)
+    end
+    
+    if !params[:report_item][:pivot].blank?
+      id, model = params[:report_item][:pivot].split('-')
+      @report_item.pivot = model.constantize.find(id)
+    end
+    
+    if @report_item.save
+      render :json => { :success => true,
+                        :close_dialog => true,
+                        :result => "<span>Successfully updated report item</span>",
+                        :also => [ { :item => ".report-report-items", :result => render_to_string( :partial => "mg/reports/report_report_items", :locals => { :report => @report_item.report }) } ] }
+    else
+      render :json => { :success => true,
+                        :result => render_to_string(:action => :edit, :layout => 'xhr') }
+    end
+  end
+  
+  #TODO: Destroy
+end

data/lib/mountain-goat/controllers/mg/reports_controller.rb

@@ -0,0 +1,90 @@
+class Mg::ReportsController < Mg
+  # GET /mg_reports
+  # GET /mg_reports.xml
+  def index
+    @reports = Mg::Report.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @reports }
+    end
+  end
+
+  # GET /mg_reports/1
+  # GET /mg_reports/1.xml
+  def show
+    @report = Mg::Report.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @report }
+    end
+  end
+  
+  def show_svg
+    @report = Mg::Report.find(params[:id])
+
+    render :text => render_to_string(:partial => "mg/reports/report", :layout => '_pdf', :locals => { :report => @report } )
+    response.content_type = 'application/xhtml+xml'
+  end
+
+  # GET /mg_reports/new
+  # GET /mg_reports/new.xml
+  def new
+    @report = Mg::Report.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @report }
+    end
+  end
+
+  # GET /mg_reports/1/edit
+  def edit
+    @report = Mg::Report.find(params[:id])
+  end
+
+  # POST /mg_reports
+  # POST /mg_reports.xml
+  def create
+    @report = Mg::Report.new(params[:report])
+
+    respond_to do |format|
+      if @report.save
+        format.html { flash[:notice] = 'Your report was successfully created, now add some report items.'; redirect_to(edit_mg_report_url @report) }
+        format.xml  { render :xml => @report, :status => :created, :location => @report }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @report.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /mg_reports/1
+  # PUT /mg_reports/1.xml
+  def update
+    @report = Mg::Report.find(params[:id])
+
+    respond_to do |format|
+      if @report.update_attributes(params[:report])
+        format.html { redirect_to(@report, :notice => 'Mg::Report was successfully updated.') }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @report.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /mg_reports/1
+  # DELETE /mg_reports/1.xml
+  def destroy
+    @report = Mg::Report.find(params[:id])
+    @report.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(mg_reports_url) }
+      format.xml  { head :ok }
+    end
+  end
+end

data/lib/mountain-goat/m_g.rb

@@ -0,0 +1,64 @@
+
+################
+# Setup PDFKit #
+################
+
+begin
+  require 'pdfkit'
+rescue LoadError
+  raise "Mountain Goat Reports will not work without the 'pdfkit' gem (please run `gem install pdfkit`)"
+end
+
+######################
+# Setup svg-graph    #
+######################
+
+begin
+  require 'SVG/Graph/TimeSeries'
+rescue LoadError
+  raise "Mountain Goat Reports will not work without the 'svg-graph' gem (please run `gem install svg-graph`)"
+end
+
+############################
+# TODO: Verify Email Setup #
+############################
+
+class MG
+  def self.deliver(delivery_set = nil)
+    mg_yml = YAML::load(File.open("#{RAILS_ROOT}/config/mountain-goat.yml"))
+    
+    if mg_yml.blank? || mg_yml[RAILS_ENV].blank? || mg_yml[RAILS_ENV]['wkhtmltopdf'].blank?
+      raise "Please configure wkhtmltopdf settings in #{RAILS_ROOT}/config/mountain-goat.yml"
+    end
+    
+    PDFKit.configure do |cz|
+      cz.wkhtmltopdf = mg_yml[RAILS_ENV]['wkhtmltopdf']
+      cz.default_options = { :'custom-header' => "'Content-Type' 'application/xhtml+xml'" }
+    end
+    
+    if delivery_set.nil?
+      reports = Mg::Report.all
+    else
+      reports = Mg::Report.find(:all, :conditions => { :delivery_set => delivery_set.to_s } )
+    end
+    
+    #We need to render the report report_show
+    reports.each do |report|
+      puts "Delivering report: #{report.title}"
+      av = ActionView::Base.new
+      av.view_paths = File.join([File.dirname(__FILE__), 'views/mountain_goat/'])
+      data = av.render(:partial => 'mg/reports/report', :layout => 'layouts/pdf', :locals => { :report => report } )
+      
+      #Oddly, the file extension matters most here
+      tmp = Tempfile.new(['chart', '.xhtml'])
+      tmp << data
+      tmp.flush
+      
+      kit = PDFKit.new(File.new(tmp.path), :page_size => 'Letter')
+      pdf = kit.to_pdf
+      tmp.close
+      
+      Mg::ReportMailer.deliver_report(report, pdf)
+    end
+  end
+end

data/lib/mountain-goat/metric_tracking.rb

@@ -7,49 +7,165 @@ module MetricTracking
     define_method :clear!, lambda {}
   end
   
-  #TODO: Namespace?
+  Mime::Type.register "application/xhtml+xml", :xhtml
+  
   ActionController::Routing::Routes.draw do |map|
-    map.mg '/mg', :controller => :mountain_goat_converts, :action => :index
-    map.mg_login '/mg/login', :controller => :mountain_goat, :action => :login
-    map.mg_login_create '/mg/login/create', :controller => :mountain_goat, :action => :login_create
-    map.resources :mountain_goat_metric_variants
-    map.resources :mountain_goat_converts, :has_many => [ :mountain_goat_metrics, :mountain_goat_rallies ]
-    map.resources :mountain_goat_metrics, :has_many => :mountain_goat_metric_variants
-    map.resources :mountain_goat_rallies
-    map.new_rallies '/mg/rallies/new', :controller => :mountain_goat_rallies, :action => :new_rallies 
-    map.fresh_metrics '/fresh-metrics', :controller => :mountain_goat_metrics, :action => :fresh_metrics
-    map.connect '/mg/public/:file', :controller => :mountain_goat, :action => :fetch
+    map.namespace :mg do |mg|
+      mg.mg '/mg', :controller => :converts, :action => :index, :path_prefix => ""
+      mg.login '/login', :controller => :mountain_goat, :action => :login
+      mg.login_create '/login/create', :controller => :mountain_goat, :action => :login_create
+      mg.resources :metric_variants
+      mg.resources :converts, :has_many => [ :rallies ]
+      mg.resources :metrics, :has_many => :metric_variants
+      mg.resources :rallies, :collection => { :new_rallies => :get }
+      mg.resources :reports, :has_many => :report_items, :member => { :show_svg => :get }
+      mg.resources :report_items, :member => { :destroy => :get, :update => :post }, :collection => { :get_extra => :get }
+      mg.resources :playground, :collection => { :test => :get }
+      mg.new_rallies '/rallies/new', :controller => :rallies, :action => :new_rallies 
+      mg.fresh_metrics '/fresh-metrics', :controller => :metrics, :action => :fresh_metrics
+      mg.connect '/public/:file', :controller => :mountain_goat, :action => :fetch
+    end
   end
   
   module Controller
   
+    #This is just for testing
+    def mg_rand
+      return "(SELECT #{@mg_i.nil? ? 1 : @mg_i.to_f})" if defined?(MOUNTAIN_GOAT_TEST) && MOUNTAIN_GOAT_TEST
+      "RAND()"
+    end
+    
+    def mg_epsilon
+      if @mg_epsilon.nil?
+        @mg_epsilon = 0.1 #default
+        mg_yml = nil
+        begin
+          mg_yml = YAML::load(File.open("#{RAILS_ROOT}/config/mountain-goat.yml"))
+        rescue
+        end
+        if mg_yml
+          if mg_yml.has_key?(RAILS_ENV) && mg_yml[RAILS_ENV].has_key?('epsilon')
+            @mg_epsilon = mg_yml[RAILS_ENV]['epsilon'].to_f
+          elsif mg_yml.has_key?('settings') && mg_yml['settings'].has_key?('epsilon')
+            @mg_epsilon = mg_yml['settings']['epsilon'].to_f
+          end
+        end
+      end
+      return @mg_epsilon
+    end
+    
+    def mg_strategy 
+      if @mg_strategy.nil?
+        @mg_strategy = 'e-greedy' #default
+        mg_yml = nil
+        begin
+          mg_yml = YAML::load(File.open("#{RAILS_ROOT}/config/mountain-goat.yml"))
+        rescue
+        end
+        if mg_yml
+          if mg_yml.has_key?(RAILS_ENV) && mg_yml[RAILS_ENV].has_key?('strategy')
+            @mg_strategy = mg_yml[RAILS_ENV]['strategy']
+          elsif mg_yml.has_key?('settings') && mg_yml['settings'].has_key?('strategy')
+            @mg_strategy = mg_yml['settings']['strategy']
+          end
+        end
+      end
+      return @mg_strategy
+    end
+    
+    def mg_apply_strategy(metric)
+      case mg_strategy.downcase
+        when 'e-greedy'
+          logger.warn Mg::MetricVariant.all(:order => "CASE WHEN served = 0 THEN 1 ELSE 0 END DESC, CASE WHEN #{mg_rand} < #{mg_epsilon.to_f} THEN #{mg_rand} ELSE CASE WHEN served = 0 THEN -1 ELSE reward / served END END DESC, #{mg_rand} DESC", :conditions => { :metric_id => metric.id } )
+          return Mg::MetricVariant.first(:order => "CASE WHEN served = 0 THEN 1 ELSE 0 END DESC, CASE WHEN #{mg_rand} < #{mg_epsilon.to_f} THEN #{mg_rand} ELSE CASE WHEN served = 0 THEN -1 ELSE reward / served END END DESC, #{mg_rand} DESC", :conditions => { :metric_id => metric.id } )
+        when 'e-greedy-decreasing'
+          return Mg::MetricVariant.first(:order => "CASE WHEN served = 0 THEN 1 ELSE 0 END DESC,
+                                                    CASE WHEN #{mg_rand} < #{mg_epsilon.to_f} / ( select sum(served) from mg_metric_variants where metric_id = #{ metric.id.to_i } ) THEN #{mg_rand} ELSE CASE WHEN served = 0 THEN -1 ELSE reward / served END END DESC,
+                                                    #{mg_rand} DESC", :conditions => { :metric_id => metric.id } ) # * log( ( select sum(served) from mg_metric_variants where metric_id = #{ metric.id.to_i } ) )
+        when 'a/b'
+          return Mg::MetricVariant.first(:order => "#{mg_rand} DESC", :conditions => { :metric_id => metric.id } )
+        else
+          raise "Invalid strategy #{mg_strategy}"
+      end
+    end
+    
+    def mg_storage 
+      if @mg_storage.nil?
+        @mg_storage = defined?(cookies) ? cookies : nil
+        
+        mg_yml = nil
+        begin
+          mg_yml = YAML::load(File.open("#{RAILS_ROOT}/config/mountain-goat.yml"))
+        rescue
+        end
+        if mg_yml
+          if mg_yml.has_key?(RAILS_ENV) && mg_yml[RAILS_ENV].has_key?('storage')
+            uc = mg_yml[RAILS_ENV]['storage'].strip
+            @mg_storage = ( uc == "cookies" && defined?(cookies) ) ? cookies : ( uc == "session" && defined?(session) ) ? session : nil
+          elsif mg_yml.has_key?('settings') && mg_yml['settings'].has_key?('storage')
+            uc = mg_yml['settings']['storage'].strip
+            @mg_storage = ( uc == "cookies" && defined?(cookies) ) ? cookies : ( uc == "session" && defined?(session) ) ? session : nil
+          end
+        end
+      end
+      @mg_storage = {} if @mg_storage.nil? #'none'
+      return @mg_storage
+    end
+    
     ######################
     #   Metric Tracking  #
     ######################
   
-    def sv(metric_type, convert_type, &block)
+    def bds(metric_type, &block)
       raise ArgumentError, "Switch variant needs block" if !block_given?
-      metric, convert = get_metric_convert( metric_type, convert_type, true )
-      block.call(SwitchVariant.new( logger, metric, convert, nil ) )
+      metric = get_metric( metric_type, true )
+      block.call(SwitchVariant.new( logger, metric, nil ) )
       
-      var = get_switch_metric_variant(metric_type, convert_type)
-      block.call(SwitchVariant.new( logger, metric, convert, var ) )
+      var = get_switch_metric_variant( metric_type )
+      block.call(SwitchVariant.new( logger, metric, var ) )
+    end
+    
+    def bd(metric_type, default, opts = {}, opt = nil)
+      return get_metric_variant(metric_type, default, opts, opt)[:value]
+    end
+    
+    def bdd(metric_type, default, opts = {}, opt = nil)
+      return get_metric_variant(metric_type, default, opts, opt)
+    end
+    
+    #Legacy
+    def sv(metric_type, convert_type, &block)
+      bds(metric_type, &block)
     end
     
     def mv(metric_type, convert_type, default, opts = {}, opt = nil)
-      return get_metric_variant(metric_type, convert_type, default, opts, opt)[:value]
+      bd(metric_type, default, opts, opt)
     end
     
     def mv_detailed(metric_type, convert_type, default, opts = {}, opt = nil)
-      return get_metric_variant(metric_type, convert_type, default, opts, opt)
+      bdd(metric_type, default, opts, opt)  
     end
     
     #shorthand
+    def rw(convert_type, reward, options = {})
+      self.bandit_reward(convert_type, reward, options)
+    end
+    
     def rc(convert_type, options = {})
-      self.record_conversion(convert_type, options)
+      self.bandit_reward(convert_type, 1, options)
     end
     
     def record_conversion(convert_type, options = {})
+      self.bandit_reward(convert_type, 1, options)
+    end
+    
+    #allows bandit_reward(convert, options)
+    def bandit_reward(convert_type, reward, options = {})
+      
+      if reward.is_a?(Hash) #allow arguments bandit_reward(convert, options)
+        options = reward
+        reward = 0
+      end
       
       metrics = {} #for user-defined metrics
       options = options.with_indifferent_access
@@ -71,18 +187,18 @@ module MetricTracking
       
       logger.warn "Recording conversion #{convert_type.to_s} with options #{options.inspect}"
       
-      convert = Convert.first( :conditions => { :convert_type => convert_type.to_s } )
+      convert = Mg::Convert.first( :conditions => { :convert_type => convert_type.to_s } )
       
       #now, we just create the convert if we don't have one
-      convert = Convert.create!( :convert_type => convert_type.to_s, :name => convert_type.to_s ) if convert.nil?
-      
+      convert = Mg::Convert.create!( :convert_type => convert_type.to_s, :name => convert_type.to_s, :reward => reward ) if convert.nil?
+        
       #first, let's tally for the conversion itself
       #we need to see what meta information we should fill based on the conversion type
-      Rally.create!( { :convert_id => convert.id } ).set_meta_data(options)
+      Mg::Rally.create!( { :convert_id => convert.id } ).set_meta_data(options)
       
       #User-defined metric tallies
       metrics.each do |metric_type, variant_id|
-        m = Metric.find_by_metric_type(metric_type)
+        m = Mg::Metric.find_by_metric_type(metric_type)
         if m.nil?
           logger.warn "Missing user-defined metric #{metric_type}"
           next
@@ -96,27 +212,27 @@ module MetricTracking
         end
         
         logger.warn "Tallying conversion #{convert.name} for #{m.title} - #{v.name} (#{v.value} - #{v.id})"
-        v.tally_convert
+        v.tally_convert(convert, reward)
       end
       
-      if defined?(cookies)
-        #we just converted, let's tally each of our metrics (from cookies)
-        convert.metrics.each do |metric|
+      if !mg_storage.nil?
+        #we just converted, let's tally each of our metrics (from cookies or session)
+        Mg::Metric.all.each do |metric|
           metric_sym = "metric_#{metric.metric_type}".to_sym
           metric_variant_sym = "metric_#{metric.metric_type}_variant".to_sym
           
-          value = cookies[metric_sym]
-          variant_id = cookies[metric_variant_sym]
+          value = mg_storage[metric_sym]
+          variant_id = mg_storage[metric_variant_sym]
           
           #logger.warn "Value: #{metric_sym} - #{value}"
           #logger.warn "Value: #{metric_variant_sym} - #{variant_id}"
           
           if variant_id.blank? #the user just doesn't have this set
-            logger.error "No variant found for #{metric.title}"
+            #This is now common-case
             next
           end
           
-          variant = MetricVariant.first(:conditions => { :id => variant_id.to_i } )
+          variant = Mg::MetricVariant.first(:conditions => { :id => variant_id.to_i } )
           
           if variant.nil?
             logger.error "Variant #{variant_id} not in metric variants for #{metric.title}"
@@ -128,7 +244,7 @@ module MetricTracking
           end
           
           logger.warn "Tallying conversion #{convert.name} for #{metric.title} - #{variant.name} (#{variant.value} - #{variant.id})"
-          variant.tally_convert
+          variant.tally_convert(convert, reward)
         end
       end
     end
@@ -136,15 +252,15 @@ module MetricTracking
     private
     
     #returns a map { :value => value, :variant_id => id }
-    def get_metric_variant(metric_type, convert_type, default, opts = {}, opt = nil)
+    def get_metric_variant(metric_type, default, opts = {}, opt = nil)
       metric_sym = "metric_#{metric_type}#{ opt.nil? ? "" : '_' + opt.to_s }".to_sym
       metric_variant_sym = "metric_#{metric_type}_variant".to_sym
       
       #first, we'll check for a cookie value
-      if defined?(cookies) && cookies[metric_sym] && !cookies[metric_sym].blank?
+      if !mg_storage.nil? && mg_storage[metric_sym] && !mg_storage[metric_sym].blank?
         #we have the cookie  
-        variant_id = cookies[metric_variant_sym]
-        variant = MetricVariant.first(:conditions => { :id => variant_id.to_i } )
+        variant_id = mg_storage[metric_variant_sym]
+        variant = Mg::MetricVariant.first(:conditions => { :id => variant_id.to_i } )
         if !variant.nil?
           if variant.metric.tally_each_serve
             variant.tally_serve
@@ -153,46 +269,44 @@ module MetricTracking
           logger.warn "Serving metric #{metric_type} #{ opt.nil? ? "" : opt.to_s } without finding / tallying variant."
         end
         
-        return { :value => cookies[metric_sym], :variant_id => cookies[metric_variant_sym] } #it's the best we can do
+        return { :value => mg_storage[metric_sym], :variant_id => mg_storage[metric_variant_sym] } #it's the best we can do
       else
         #we don't have the cookie, let's find a value to set
-        metric, convert = get_metric_convert( metric_type, convert_type, false )
+        metric = get_metric( metric_type, false )
         
-        #to use RAND(), let's not use metrics.metric_variants
-        sum_priority = MetricVariant.first(:select => "SUM(priority) as sum_priority", :conditions => { :metric_id => metric.id } ).sum_priority.to_f
-        
-        if sum_priority > 0.0
-          metric_variant = MetricVariant.first(:order => "RAND() * ( priority / #{sum_priority.to_f} ) DESC", :conditions => { :metric_id => metric.id } )
-        end
+        metric_variant = mg_apply_strategy(metric)
         
         if metric_variant.nil?
           logger.warn "Missing metric variants for #{metric_type}"
-          metric_variant = MetricVariant.create!( { :metric_id => metric.id, :value => default, :name => default }.merge(opts) )
+          metric_variant = Mg::MetricVariant.create!( { :metric_id => metric.id, :value => default, :name => default }.merge(opts) )
+        end
+        
+        if metric_variant.metric.tally_each_serve
+          metric_variant.tally_serve #donate we served this to a user
         end
         
-        metric_variant.tally_serve #donate we served this to a user
         value = metric_variant.read_attribute( opt.nil? ? :value : opt )
         logger.debug "Serving #{metric_variant.name} (#{value}) for #{metric_sym}"
         #good, we have a variant, let's store it in session
         
-        if defined?(cookies)
-          cookies[metric_sym] = { :value => value } #, :domain => WILD_DOMAIN
-          cookies[metric_variant_sym] = { :value => metric_variant.id } #, :domain => WILD_DOMAIN
+        if !mg_storage.nil?
+          mg_storage[metric_sym] = value #, :domain => WILD_DOMAIN
+          mg_storage[metric_variant_sym] = metric_variant.id #, :domain => WILD_DOMAIN
         end
         
         return { :value => value, :variant_id => metric_variant.id }
       end
     end
     
-    def get_switch_metric_variant(metric_type, convert_type)
+    def get_switch_metric_variant(metric_type)
       metric_variant_sym = "metric_#{metric_type}_variant".to_sym
       
       #first, we'll check for a cookie selection
-      if defined?(cookies) && cookies[metric_variant_sym] && !cookies[metric_variant_sym].blank?
+      if !mg_storage.nil? && mg_storage[metric_variant_sym] && !mg_storage[metric_variant_sym].blank?
         #we have the cookie
         
-        variant_id = cookies[metric_variant_sym]
-        variant = MetricVariant.first(:conditions => { :id => variant_id.to_i } )
+        variant_id = mg_storage[metric_variant_sym]
+        variant = Mg::MetricVariant.first(:conditions => { :id => variant_id.to_i } )
         if !variant.nil?
         
           if variant.metric.tally_each_serve
@@ -208,46 +322,38 @@ module MetricTracking
       end
         
       #we don't have the cookie, let's find a value to set
-      metric, convert = get_metric_convert( metric_type, convert_type, true )
+      metric = get_metric( metric_type, true )
       
-      #to use RAND(), let's not use metrics.metric_variants
-      sum_priority = MetricVariant.first(:select => "SUM(priority) as sum_priority", :conditions => { :metric_id => metric.id } ).sum_priority.to_f
-      
-      if sum_priority > 0.0
-        metric_variant = MetricVariant.first(:order => "RAND() * ( priority / #{sum_priority.to_f} ) DESC", :conditions => { :metric_id => metric.id } )
-      end
+      metric_variant = mg_apply_strategy(metric)
       
       if metric_variant.nil?
         logger.warn "Missing metric variants for #{metric_type}"
         raise ArgumentError, "Missing variants for switch-type #{metric_type}"
       end
       
-      metric_variant.tally_serve #donate we served this to a user
+      if metric_variant.metric.tally_each_serve
+        metric_variant.tally_serve #donate we served this to a user
+      end
+      
       logger.debug "Serving #{metric_variant.name} (#{metric_variant.switch_type}) for #{metric.title} (switch-type)"
       #good, we have a variant, let's store it in session (not the value, just the selection)
-      if defined?(cookies)
-        cookies[metric_variant_sym] = { :value => metric_variant.id } #, :domain => WILD_DOMAIN
+      if !mg_storage.nil?
+        mg_storage[metric_variant_sym] = metric_variant.id #, :domain => WILD_DOMAIN
       end
       
       return metric_variant
     end
     
-    def get_metric_convert(metric_type, convert_type, is_switch = false)
+    def get_metric(metric_type, is_switch = false)
       
-      metric = Metric.first(:conditions => { :metric_type => metric_type.to_s } )
+      metric = Mg::Metric.first(:conditions => { :metric_type => metric_type.to_s } )
       
-      conv = Convert.find_by_convert_type( convert_type.to_s )
-      if conv.nil?
-        logger.warn "Missing convert type #{convert_type.to_s} -- creating"  
-        conv = Convert.create( :convert_type => convert_type.to_s, :name => convert_type.to_s ) if conv.nil?
-      end
-        
       if metric.nil? #we don't have a metric of this type
         logger.warn "Missing metric type #{metric_type.to_s} -- creating"
-        metric = Metric.create( :metric_type => metric_type.to_s, :title => metric_type.to_s, :convert_id => conv.id, :is_switch => is_switch )
+        metric = Mg::Metric.create( :metric_type => metric_type.to_s, :title => metric_type.to_s, :is_switch => is_switch )
       end
       
-      return metric, conv
+      return metric
     end
   end
   
@@ -263,6 +369,18 @@ module MetricTracking
     def sv(*args, &block)
       @controller.send(:sv, *args, &block)
     end
+    
+    def bd(*args, &block)
+      @controller.send(:bd, *args, &block)
+    end
+    
+    def bdd(*args, &block)
+      @controller.send(:bdd, *args, &block)
+    end
+    
+    def bds(*args, &block)
+      @controller.send(:bds, *args, &block)
+    end
   end
 end