stefl-sinmetrics 0.0.9

data/.gitignore

@@ -0,0 +1,2 @@
+coverage
+*.gem

data/README

@@ -0,0 +1,33 @@
+sinmetrics: simple sinatra metrics helpers
+  (c) 2010 Luke Petre (lpetre)
+
+=== Usage
+
+  require 'sinmetrics'
+  require 'sinatra'
+
+  mixpanel do
+    token  '4579...cbb0'
+  end
+
+  get '/' do
+    mp.log_event( 'play', @user.id)
+    "hello world"
+  end
+
+=== Features
+
+=== Other Options
+
+=== Standalone Usage
+
+  require 'sinmetrics'
+  mp = MixPanel.new(
+    :token  => '4579...cbb0',
+  )
+
+  >> mp.log_event( 'play', 1234 )
+  => 1
+
+=== Special Thanks
+  This library is *heavily* inspired by sinbook, http://github.com/tmm1/sinbook

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "stefl-sinmetrics"
+    gemspec.summary = "simple sinatra metrics extension"
+    gemspec.description = "A full-featured metrics extension for the sinatra webapp framework"
+    gemspec.email = "lpetre@gmail.com"
+    gemspec.homepage = "http://github.com/stefl/sinmetrics"
+    gemspec.authors = ["Luke Petre"]
+    gemspec.add_dependency('activesupport', '>= 3.0.0')
+    gemspec.add_dependency('dm-core',         '>= 1.0.0')
+    gemspec.add_dependency('dm-transactions', '>= 1.0.0')
+    gemspec.add_dependency('dm-aggregates',   '>= 1.0.0')
+    gemspec.add_dependency('dm-validations',  '>= 1.0.0')
+    gemspec.add_dependency('dm-adjust',       '>= 1.0.0')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+task :default => :spec
+
+begin
+  require 'spec/rake/spectask'
+  desc "Run all examples"
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ['-cubfs']
+  end
+
+  Spec::Rake::SpecTask.new('spec:rcov') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ['-cfs']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'gems,spec/,examples/']
+  end
+  
+  require 'spec/rake/verify_rcov'
+  RCov::VerifyTask.new(:verify_rcov => 'spec:rcov') do |t|
+    t.threshold = 77.0
+    t.require_exact_threshold = false
+  end
+  
+rescue LoadError
+  puts "spec targets require RSpec"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.9

data/lib/sinmetrics.rb

@@ -0,0 +1,12 @@
+begin
+  require 'sinatra/base'
+rescue LoadError
+  retry if require 'rubygems'
+  raise
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/sinmetrics')
+
+require 'abingo'
+require 'kontagent'
+require 'mixpanel'

data/lib/sinmetrics/abingo.rb

@@ -0,0 +1,282 @@
+#This class is outside code's main interface into the ABingo A/B testing framework.
+#Unless you're fiddling with implementation details, it is the only one you need worry about.
+
+#Usage of ABingo, including practical hints, is covered at http://www.bingocardcreator.com/abingo
+
+begin
+  require 'sinatra/base'
+  require 'active_support'
+rescue LoadError
+  retry if require 'rubygems'
+  raise
+end
+
+
+module Sinatra  
+  class AbingoObject
+    
+    #Defined options:
+    #  :enable_specification => if true, allow params[test_name] to override the calculated value for a test.
+    def initialize app={}
+      if app.respond_to?(:options)
+        @app = app
+        [:identity, :enable_specification, :cache, :salt].each do |var|
+          begin
+            instance_variable_set("@#{var}", app.options.send("abingo_#{var}"))
+          rescue NoMethodError
+          end
+        end
+      else
+        [:identity, :enable_specification, :cache, :salt].each do |var|
+          instance_variable_set("@#{var}", app[var]) if app.has_key?(var)
+        end
+      end      
+      @identity ||= rand(10 ** 10).to_i.to_s
+      @cache ||= ActiveSupport::Cache::MemoryStore.new
+      @salt ||= ''
+    end
+
+    attr_reader :app, :enable_specification, :cache, :salt
+    attr_accessor :identity
+
+    #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 choice
+      else
+        choice
+      end
+    end
+
+    #This is the meat of A/Bingo.
+    #options accepts
+    #  :multiple_participation (true or false)
+    #  :no_particiation (true or false)
+    def test(test_name, alternatives, options = {})
+      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
+    
+      choice = find_alternative_for_user(test_name, alternatives)
+      score_participation!(test_name, options) unless options[:no_participation]
+
+      if block_given?
+        yield(choice)
+      else
+        choice
+      end
+    end
+
+    #Scores conversions for tests.
+    #test_name_or_array supports three types of input:
+    #
+    #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.
+    #
+    #nil: score a conversion for every test the u
+    def bingo!(name = nil, options = {})
+      if name.kind_of? Array
+        name.map do |single_test|
+          self.bingo!(single_test, options)
+        end
+      else
+        if name.nil?
+          #Score all participating tests
+          participating_tests = cache.read("Abingo::participating_tests::#{identity}") || []
+          participating_tests.each do |participating_test|
+            self.bingo!(participating_test, options)
+          end
+        else
+          self.score_conversion!(name.to_s, options)
+        end
+      end
+    end
+
+    #protected
+
+    #For programmer convenience, we allow you to specify what the alternatives for
+    #an experiment are in a few ways.  Thus, we need to actually be able to handle
+    #all of them.  We fire this parser very infrequently (once per test, typically)
+    #so it can be as complicated as we want.
+    #   Integer => a number 1 through N
+    #   Range   => a number within the range
+    #   Array   => an element of the array.
+    #   Hash    => assumes a hash of something to int.  We pick one of the 
+    #              somethings, weighted accorded to the ints provided.  e.g.
+    #              {:a => 2, :b => 3} produces :a 40% of the time, :b 60%.
+    #
+    #Alternatives are always represented internally as an array.
+    def parse_alternatives(alternatives)
+      if alternatives.kind_of? Array
+        return alternatives
+      elsif alternatives.kind_of? Integer
+        return (1..alternatives).to_a
+      elsif alternatives.kind_of? Range
+        return alternatives.to_a
+      elsif alternatives.kind_of? Hash
+        alternatives_array = []
+        alternatives.each do |key, value|
+          if value.kind_of? Integer
+            alternatives_array += [key] * value
+          else
+            raise "You gave a hash with #{key} => #{value} as an element.  The value must be an integral weight."
+          end
+        end
+        return alternatives_array
+      else
+        raise "I don't know how to turn [#{alternatives}] into an array of alternatives."
+      end
+    end
+
+    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
+
+      #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
+    
+    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 = {})
+      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)
+          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
+            cache.write(cache_key, 1)
+          end
+        end
+      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
+      if (experiment.status != "Completed")
+        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
+    def conversion_rate
+      return 0 if participants == 0
+      1.0 * conversions / participants
+    end
+
+    def pretty_conversion_rate
+      sprintf("%4.2f%%", conversion_rate * 100)
+    end
+  end
+  
+  module AbingoHelper
+    def abingo
+      env['abingo.helper'] ||= AbingoObject.new(self)
+    end
+    
+    def ab_test(test_name, alternatives = nil, options = {})
+      if (abingo.enable_specification && !params[test_name].blank?)
+        choice = params[test_name]
+      elsif (alternatives.nil?)
+        choice = abingo.flip(test_name)
+      else
+        choice = abingo.test(test_name, alternatives, options)
+      end
+
+      if block_given?
+        yield(choice)
+      else
+        choice
+      end
+    end
+    
+    alias ab abingo
+  end
+  
+  class AbingoSettings
+    def initialize app, &blk
+      @app = app
+      instance_eval &blk
+    end
+    %w[identity backend enable_specification cache salt].each do |param|
+      class_eval %[
+        def #{param} val, &blk
+          @app.set :abingo_#{param}, val
+        end
+      ]
+    end
+  end
+
+  module Abingo
+    def abingo &blk
+      AbingoSettings.new(self, &blk)
+    end
+    
+    def self.registered app
+      app.helpers AbingoHelper
+    end
+  end
+  
+  Application.register Abingo
+end
+
+Abingo = Sinatra::AbingoObject
+
+require 'dm-core'
+require 'dm-transactions'
+require 'dm-aggregates'
+require 'dm-validations'
+require 'dm-adjust'
+require 'abingo/statistics'
+require 'abingo/alternative'
+require 'abingo/experiment'

data/lib/sinmetrics/abingo/alternative.rb

@@ -0,0 +1,13 @@
+class Abingo::Alternative
+  include Abingo::ConversionRate
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :content, String
+  property :lookup, String, :length => 32, :index => true
+  property :weight, Integer, :default => 1
+  property :participants, Integer, :default => 0
+  property :conversions, Integer, :default => 0
+
+  belongs_to :experiment
+end

data/lib/sinmetrics/abingo/experiment.rb

@@ -0,0 +1,69 @@
+class Abingo::Experiment
+  include DataMapper::Resource
+  include Abingo::Statistics
+  include Abingo::ConversionRate
+
+  property :test_name, String, :key => true
+  property :status, String
+  property :short_circuit, String
+  
+  has n, :alternatives, "Alternative"
+
+  def cache_keys
+  ["Abingo::Experiment::exists(#{test_name})".gsub(" ", "_"),
+    "Abingo::Experiment::#{test_name}::alternatives".gsub(" ","_"),
+    "Abingo::Experiment::short_circuit(#{test_name})".gsub(" ", "_")
+  ]
+  end
+  
+  def before_destroy
+    cache_keys.each do |key|
+      Abingo.cache.delete key
+    end
+    true
+  end
+
+  def participants
+    alternatives.sum(:participants)
+  end
+
+  def conversions
+    alternatives.sum(:conversions)
+  end
+
+  def best_alternative
+    alts = Array.new alternatives.each { |a| a }
+    alts.max do |a,b|
+      a.conversion_rate <=> b.conversion_rate
+    end
+  end
+
+  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)
+      experiment.alternatives.destroy  #Blows away alternatives for pre-existing experiments.
+      while (cloned_alternatives_array.size > 0)
+        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.calculate_alternative_lookup(test_name, alt))
+        cloned_alternatives_array -= [alt]
+      end
+      experiment.status = "Live"
+      experiment.save
+      experiment
+    end
+  end
+
+  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", :short_circuit => final_alternative)
+    end
+  end
+
+end

data/lib/sinmetrics/abingo/statistics.rb

@@ -0,0 +1,90 @@
+#Designed to be included into Abingo::Experiment, but you can feel free to adapt this
+#to anything you want.
+
+module Abingo::Statistics
+
+  HANDY_Z_SCORE_CHEATSHEET = [[0.10, 1.29], [0.05, 1.65], [0.01, 2.33], [0.001, 3.08]]
+  
+  PERCENTAGES = {0.10 => '90%', 0.05 => '95%', 0.01 => '99%', 0.001 => '99.9%'}
+  
+  DESCRIPTION_IN_WORDS = {0.10 => 'fairly confident', 0.05 => 'confident',
+                         0.01 => 'very confident', 0.001 => 'extremely confident'}
+  def zscore
+    if alternatives.size != 2
+      raise "Sorry, can't currently automatically calculate statistics for A/B tests with > 2 alternatives."
+    end
+
+    if (alternatives[0].participants == 0) || (alternatives[1].participants == 0)
+      raise "Can't calculate the z score if either of the alternatives lacks participants."
+    end
+
+    cr1 = alternatives[0].conversion_rate
+    cr2 = alternatives[1].conversion_rate
+
+    n1 = alternatives[0].participants
+    n2 = alternatives[1].participants
+
+    numerator = cr1 - cr2
+    frac1 = cr1 * (1 - cr1) / n1
+    frac2 = cr2 * (1 - cr2) / n2
+
+    numerator / ((frac1 + frac2) ** 0.5)
+  end
+
+  def p_value
+    index = 0
+    z = zscore
+    z = z.abs
+    found_p = nil
+    while index < HANDY_Z_SCORE_CHEATSHEET.size do
+      if (z > HANDY_Z_SCORE_CHEATSHEET[index][1])
+        found_p = HANDY_Z_SCORE_CHEATSHEET[index][0]
+      end
+      index += 1
+    end
+    found_p
+  end
+
+  def is_statistically_significant?(p = 0.05)
+    p_value <= p
+  end
+  
+  def pretty_conversion_rate
+    sprintf("%4.2f%%", conversion_rate * 100)
+  end
+
+  def describe_result_in_words
+    begin
+      z = zscore
+    rescue
+      return "Could not execute the significance test because one or more of the alternatives has not been seen yet."
+    end
+    p = p_value
+
+    words = ""
+    if (alternatives[0].participants < 10) || (alternatives[1].participants < 10)
+      words += "Take these results with a grain of salt since your samples are so small: "
+    end
+
+    alts = alternatives - [best_alternative]
+    worst_alternative = alts.first
+
+    words += "The best alternative you have is: [#{best_alternative.content}], which had "
+    words += "#{best_alternative.conversions} conversions from #{best_alternative.participants} participants "
+    words += "(#{best_alternative.pretty_conversion_rate}).  The other alternative was [#{worst_alternative.content}], "
+    words += "which had #{worst_alternative.conversions} conversions from #{worst_alternative.participants} participants "
+    words += "(#{worst_alternative.pretty_conversion_rate}).  "
+
+    if (p.nil?)
+      words += "However, this difference is not statistically significant."
+    else
+      words += "This difference is #{PERCENTAGES[p]} likely to be statistically significant, which means you can be "
+      words += "#{DESCRIPTION_IN_WORDS[p]} that it is the result of your alternatives actually mattering, rather than "
+      words += "being due to random chance.  However, this statistical test can't measure how likely the currently "
+      words += "observed magnitude of the difference is to be accurate or not.  It only says \"better\", not \"better "
+      words += "by so much\"."
+    end
+    words
+  end
+
+end

data/lib/sinmetrics/kontagent.rb

@@ -0,0 +1,128 @@
+begin
+  require 'sinatra/base'
+rescue LoadError
+  retry if require 'rubygems'
+  raise
+end
+
+module Sinatra
+  require 'digest/md5'
+  require 'net/http'
+
+  class KontagentObject
+    @@version = 1
+    def initialize app
+      if app.respond_to?(:options)
+        @app = app
+        [:api_key, :secret, :env].each do |var|
+          instance_variable_set("@#{var}", app.options.send("kontagent_#{var}"))
+        end
+      else
+        @request = Proc.new { |url| Net::HTTP.get( URI.parse(url) ) }
+        [:api_key, :secret, :env, :request].each do |var|
+          instance_variable_set("@#{var}", app[var]) if app.has_key?(var)
+        end
+      end
+    end
+
+    attr_reader :app
+    attr_accessor :api_key, :secret, :env
+    def request *args
+      if @app
+        @app.options.kontagent_request *args
+      else
+        @request.call *args
+      end
+    end
+
+    class APIProxy
+      Types = %w[ 
+        ins inr
+        nts ntr
+        nes nei
+        pst psr
+        apa apr
+        mes mer
+        ucc
+        pgr
+        cpu
+        gci
+        mtu
+      ]
+    end
+
+    APIProxy::Types.each do |n|
+      class_eval %[
+        def #{n}_url args
+          make_url '#{n}', args
+        end
+        def #{n} args = {}
+          request( #{n}_url( args ) ) unless env == :test
+        end
+      ]
+    end
+    
+    def base_url
+      case env
+      when :production ; 'http://api.geo.kontagent.net/api'
+      else ;             'http://api.test.kontagent.com/api'
+      end
+    end
+    
+    def make_url method, args = {}
+      args = { :ts => Time.now.getgm.strftime("%Y-%m-%dT%H:%M:%S") }.merge(args)
+      sorted = args.map{ |k,v|
+                       next nil unless v
+                       next nil if k == :url_only
+                       "#{k}=" + case v
+                                  when Array
+                                    v.join('%2C')
+                                  else
+                                    v.to_s
+                                  end
+                     }.compact.sort
+
+      sorted << "an_sig=" + Digest::MD5.hexdigest(sorted.join+self.secret)
+      query = sorted.map{|v| v.gsub('&', '%26').gsub(' ', '+')}.join('&')
+      "#{base_url}/v#{@@version}/#{api_key}/#{method}/?#{query}"
+    end
+  end
+
+  module KontagentHelper
+    def kontagent
+      env['kontagent.helper'] ||= KontagentObject.new(self)
+    end
+    
+    alias kt kontagent
+  end
+  
+  class KontagentSettings
+    def initialize app, &blk
+      @app = app
+      @app.set :kontagent_env, @app.environment
+      @app.set :kontagent_request, Proc.new { |url| Net::HTTP.get( URI.parse(url) ) }
+      instance_eval &blk
+    end
+    %w[ api_key secret env request ].each do |param|
+      class_eval %[
+        def #{param} val, &blk
+          @app.set :kontagent_#{param}, val
+        end
+      ]
+    end
+  end
+
+  module Kontagent
+    def kontagent &blk
+      KontagentSettings.new(self, &blk)
+    end
+    
+    def self.registered app
+      app.helpers KontagentHelper
+    end
+  end
+  
+  Application.register Kontagent  
+end
+
+Kontagent = Sinatra::KontagentObject

data/lib/sinmetrics/mixpanel.rb

@@ -0,0 +1,97 @@
+module Sinatra
+  require 'digest/md5'
+  require 'base64'
+  require 'net/http'
+
+  class MixpanelObject
+    @@version = 1
+    def initialize app
+      if app.respond_to?(:options)
+        @app = app
+        [:api_key, :secret, :token].each do |var|
+          instance_variable_set("@#{var}", app.options.send("mixpanel_#{var}"))
+        end
+      else
+        @request = Proc.new { |url| Net::HTTP.get( URI.parse(url) ) }
+        [:api_key, :secret, :token, :request ].each do |var|
+          instance_variable_set("@#{var}", app[var]) if app.has_key?(var)
+        end
+      end
+    end
+
+    attr_reader :app
+    attr_accessor :api_key, :secret, :token
+
+    def request *args
+      if @app
+        @app.options.mixpanel_request *args
+      else
+        @request.call *args
+      end
+    end
+    
+    def log_event(event, user_id, opts = {})      
+      options = {}
+      options['ip'] = @app.request.ip if @app
+      options['time'] = Time.now.to_i
+      options['token'] = token
+      options['distinct_id'] = user_id if user_id
+      opts.each do |key, value|
+        if [:step].include? key
+          options[key.to_s] = value.to_i
+        else
+          options[key.to_s] = value.to_s
+        end
+      end
+      
+      data = ::Base64.encode64( { 'event' => event, 'properties' => options }.to_json ).gsub(/\n/, '')
+      data = "#{data}&ip=1" if options.has_key? 'ip'
+      request "http://api.mixpanel.com/track/?data=#{data}"
+    end
+
+    def log_funnel(funnel_name, step_number, step_name, user_id, opts = {})
+      funnel_opts = opts.merge({:funnel => funnel_name, :step => step_number, :goal => step_name})
+      log_event("mp_funnel", user_id, funnel_opts)
+    end
+
+  end
+
+  module MixpanelHelper
+    def mixpanel
+      env['mixpanel.helper'] ||= MixpanelObject.new(self)
+    end
+    
+    alias mp mixpanel
+  end
+  
+  class MixpanelSettings
+    def initialize app, &blk
+      @app = app
+      @app.set :mixpanel_api_key, nil
+      @app.set :mixpanel_secret, nil
+      @app.set :mixpanel_request, Proc.new { |url| Net::HTTP.get(URI.parse(url)) }
+      instance_eval &blk
+    end
+    %w[ api_key secret token request ].each do |param|
+      class_eval %[
+        def #{param} val, &blk
+          @app.set :mixpanel_#{param}, val
+        end
+      ]
+    end
+  end
+
+  module Mixpanel
+    def mixpanel &blk
+      MixpanelSettings.new(self, &blk)
+    end
+    
+    def self.registered app
+      app.helpers MixpanelHelper
+    end
+  end
+  
+  Application.register Mixpanel  
+end
+
+Mixpanel = Sinatra::MixpanelObject

data/spec/abingo_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe 'Sinatra Abingo' do
+  
+  it 'should be configurable standalone' do
+    ab = Abingo.new :identity => 'abcd'
+  end
+  
+  it 'should be configurable w/in sinatra' do
+    class AbingoApp < Sinatra::Base
+      register Sinatra::Abingo
+      abingo do
+        identity 'abcd'
+      end
+    end
+  
+    app = AbingoApp.new
+  end
+
+end
+
+describe 'Abingo Specs' do
+  before :each do
+    @abingo = Abingo.new
+  end
+    
+  it "should automatically assign identity" do
+    @abingo.identity.should_not be_nil
+  end
+
+  it "should parse alternatives" do
+    array = %w{a b c}
+    @abingo.parse_alternatives(array).should == array
+    @abingo.parse_alternatives(65).size.should == 65
+    @abingo.parse_alternatives(2..5).size.should == 4
+    @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
+    alternatives = %w{A B}
+    alternative_selected = @abingo.test("unit_test_sample_A", alternatives)
+    Abingo::Experiment.count.should == 1
+    Abingo::Alternative.count.should == 2
+    alternatives.should include(alternative_selected)
+  end
+  
+  it "should pick alternatives consistently" do
+    alternative_picked = @abingo.test("consistency_test", 1..100)
+    100.times do
+      @abingo.test("consistency_test", 1..100).should == alternative_picked
+    end
+  end
+  
+  it "should have working participation" do
+    new_tests = %w{participationA participationB participationC}
+    new_tests.map do |test_name|
+      @abingo.test(test_name, 1..5)
+    end
+
+    participating_tests = @abingo.cache.read("Abingo::participating_tests::#{@abingo.identity}") || []
+
+    new_tests.map do |test_name|
+      participating_tests.should include(test_name)
+    end
+  end
+
+  it "should count participants" do
+    test_name = "participants_counted_test"
+    alternative = @abingo.test(test_name, %w{a b c})
+
+    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
+  end
+
+  it "should track conversions by test name" do
+    test_name = "conversion_test_by_name"
+    alternative = @abingo.test(test_name, %w{a b c})
+    @abingo.bingo!(test_name)
+    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
+
+    @abingo.bingo!(test_name)
+
+    #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.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, {'a' => 3, 'b' => 2, 'c' => 1})
+    @abingo.bingo!(test_name)
+    ex = Abingo::Experiment.get(test_name)
+    ex.best_alternative.content.should == alternative
+  end
+  
+  it "should be possible to short circuit tests" do
+    test_name = "short circuit test"
+    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)
+
+    ex.reload
+    ex.status.should == "Finished"
+    
+    @abingo.bingo!(test_name)  #Should not be counted, test is over.
+    ex.conversions.should == 0
+
+    old_identity = @abingo.identity
+    @abingo.identity = "shortCircuitTestNewIdentity"
+    @abingo.test(test_name, %w{A B})
+    @abingo.identity = old_identity
+    ex.reload
+
+    # Original identity counted, new identity not counted b/c test stopped
+    ex.participants.should == 1
+  end
+end  
+  

data/spec/kontagent_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Sinatra Kontagent' do
+  
+  it 'should be configurable standalone' do
+    kontagent = Kontagent.new :api_key => '1234', :secret => '5678'
+  end
+  
+  it 'should be configurable w/in sinatra' do
+    class KontagentApp < Sinatra::Base
+      register Sinatra::Kontagent
+      kontagent do
+        api_key "1234"
+        secret  "5678"
+      end
+    end
+    
+    app = KontagentApp.new
+  end
+    
+  
+end  
+  

data/spec/mixpanel_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Sinatra Mixpanel' do  
+
+  it 'should be configurable standalone' do
+    mp = Mixpanel.new :token => "abcdefghijklmnopqrstuvwyxz"
+  end
+  
+  it 'should be configurable w/in sinatra' do
+    class MixpanelApp < Sinatra::Base
+      register Sinatra::Mixpanel
+      mixpanel do
+        token "abcdefghijklmnopqrstuvwyxz"
+      end
+    end
+    
+    app = MixpanelApp.new
+  end
+end  
+  

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'spec'
+require 'sinmetrics'
+require 'dm-migrations'
+
+# establish in-memory database for testing
+#DataMapper::Logger.new($stdout, :debug)
+DataMapper.setup(:default, "sqlite3::memory:")
+
+Spec::Runner.configure do |config|
+  # reset database before each example is run
+  config.before(:each) { DataMapper.auto_migrate! }
+end

data/stefl-sinmetrics.gemspec

@@ -0,0 +1,76 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{stefl-sinmetrics}
+  s.version = "0.0.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Luke Petre"]
+  s.date = %q{2010-10-05}
+  s.description = %q{A full-featured metrics extension for the sinatra webapp framework}
+  s.email = %q{lpetre@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "lib/sinmetrics.rb",
+     "lib/sinmetrics/abingo.rb",
+     "lib/sinmetrics/abingo/alternative.rb",
+     "lib/sinmetrics/abingo/experiment.rb",
+     "lib/sinmetrics/abingo/statistics.rb",
+     "lib/sinmetrics/kontagent.rb",
+     "lib/sinmetrics/mixpanel.rb",
+     "spec/abingo_spec.rb",
+     "spec/kontagent_spec.rb",
+     "spec/mixpanel_spec.rb",
+     "spec/spec_helper.rb",
+     "stefl-sinmetrics.gemspec"
+  ]
+  s.homepage = %q{http://github.com/stefl/sinmetrics}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{simple sinatra metrics extension}
+  s.test_files = [
+    "spec/abingo_spec.rb",
+     "spec/kontagent_spec.rb",
+     "spec/mixpanel_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0"])
+      s.add_runtime_dependency(%q<dm-core>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<dm-transactions>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<dm-aggregates>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<dm-validations>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<dm-adjust>, [">= 1.0.0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 3.0.0"])
+      s.add_dependency(%q<dm-core>, [">= 1.0.0"])
+      s.add_dependency(%q<dm-transactions>, [">= 1.0.0"])
+      s.add_dependency(%q<dm-aggregates>, [">= 1.0.0"])
+      s.add_dependency(%q<dm-validations>, [">= 1.0.0"])
+      s.add_dependency(%q<dm-adjust>, [">= 1.0.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 3.0.0"])
+    s.add_dependency(%q<dm-core>, [">= 1.0.0"])
+    s.add_dependency(%q<dm-transactions>, [">= 1.0.0"])
+    s.add_dependency(%q<dm-aggregates>, [">= 1.0.0"])
+    s.add_dependency(%q<dm-validations>, [">= 1.0.0"])
+    s.add_dependency(%q<dm-adjust>, [">= 1.0.0"])
+  end
+end
+

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification 
+name: stefl-sinmetrics
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 9
+  version: 0.0.9
+platform: ruby
+authors: 
+- Luke Petre
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-05 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dm-transactions
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: dm-aggregates
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: dm-validations
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: dm-adjust
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id006
+description: A full-featured metrics extension for the sinatra webapp framework
+email: lpetre@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- lib/sinmetrics.rb
+- lib/sinmetrics/abingo.rb
+- lib/sinmetrics/abingo/alternative.rb
+- lib/sinmetrics/abingo/experiment.rb
+- lib/sinmetrics/abingo/statistics.rb
+- lib/sinmetrics/kontagent.rb
+- lib/sinmetrics/mixpanel.rb
+- spec/abingo_spec.rb
+- spec/kontagent_spec.rb
+- spec/mixpanel_spec.rb
+- spec/spec_helper.rb
+- stefl-sinmetrics.gemspec
+has_rdoc: true
+homepage: http://github.com/stefl/sinmetrics
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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.7
+signing_key: 
+specification_version: 3
+summary: simple sinatra metrics extension
+test_files: 
+- spec/abingo_spec.rb
+- spec/kontagent_spec.rb
+- spec/mixpanel_spec.rb
+- spec/spec_helper.rb