vanity 1.3.0 → 1.4.0.beta

data/lib/vanity/backport.rb

@@ -24,20 +24,3 @@ class Date
   end
 end
 
-class Symbol
-  unless method_defined?(:to_proc)
-    # Backported from Ruby 1.9.
-    def to_proc
-      Proc.new { |*args| args.shift.__send__(self, *args) }
-    end
-  end
-end
-
-class Array
-  unless method_defined?(:minmax)
-    # Backported from Ruby 1.9.
-    def minmax
-      [min, max]
-    end
-  end
-end 

data/lib/vanity/commands/upgrade.rb

@@ -0,0 +1,34 @@
+module Vanity
+  module Commands
+    class << self
+      # Upgrade to newer version of Vanity (this usually means doing magic in
+      # the database)
+      def upgrade
+        if Vanity.playground.connection.respond_to?(:redis)
+          redis = Vanity.playground.connection.redis
+          # Upgrade metrics from 1.3 to 1.4
+          keys = redis.keys("metrics:*")
+          if keys.empty?
+            puts "No metrics to upgrade"
+          else
+            puts "Updating #{keys.map { |name| name.split(":")[1] }.uniq.length} metrics"
+            keys.each do |key|
+              key << ":value:0" if key[/\d{4}-\d{2}-\d{2}$/] 
+              redis.renamenx key, "vanity:#{key}"
+            end
+          end
+          # Upgrade experiments from 1.3 to 1.4
+          keys = redis.keys("vanity:1:*")
+          if keys.empty?
+            puts "No experiments to upgrade"
+          else
+            puts "Updating #{keys.map { |name| name.split(":")[2] }.uniq.length} experiments"
+            keys.each do |key|
+              redis.renamenx key, key.gsub(":1:", ":experiments:")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vanity/experiment/ab_test.rb

@@ -93,7 +93,6 @@ module Vanity
 
       def initialize(*args)
         super
-        @alternatives = [false, true]
       end
 
 
@@ -130,22 +129,18 @@ module Vanity
       #   alts = experiment(:background_color).alternatives
       #   puts "#{alts.count} alternatives, with the colors: #{alts.map(&:value).join(", ")}"
       def alternatives(*args)
-        unless args.empty?
-          @alternatives = args.clone
-        end
+        @alternatives = args.empty? ? [true, false] : args.clone
         class << self
           define_method :alternatives, instance_method(:_alternatives)
         end
-        alternatives
+        nil
       end
 
       def _alternatives
         alts = []
         @alternatives.each_with_index do |value, i|
-          participants = redis.scard(key("alts:#{i}:participants")).to_i
-          converted = redis.scard(key("alts:#{i}:converted")).to_i
-          conversions = redis[key("alts:#{i}:conversions")].to_i
-          alts << Alternative.new(self, i, value, participants, converted, conversions)
+          counts = @playground.collecting? ? connection.ab_counts(@id, i) : Hash.new(0)
+          alts << Alternative.new(self, i, value, counts[:participants], counts[:converted], counts[:conversions])
         end
         alts
       end
@@ -186,16 +181,22 @@ module Vanity
       # @example
       #   color = experiment(:which_blue).choose
       def choose
-        if active?
-          identity = identity()
-          index = redis[key("participant:#{identity}:show")]
-          unless index
-            index = alternative_for(identity)
-            redis.sadd key("alts:#{index}:participants"), identity
-            check_completion!
+        if @playground.collecting?
+          if active?
+            identity = identity()
+            index = connection.ab_showing(@id, identity)
+            unless index
+              index = alternative_for(identity)
+              connection.ab_add_participant @id, index, identity
+              check_completion!
+            end
+          else
+            index = connection.ab_get_outcome(@id) || alternative_for(identity)
           end
         else
-          index = redis[key("outcome")] || alternative_for(identity)
+          identity = identity()
+          @showing ||= {}
+          @showing[identity] ||= alternative_for(identity)
         end
         @alternatives[index.to_i]
       end
@@ -227,12 +228,17 @@ module Vanity
       #     experiment(:green_button).select(nil)
       #   end
       def chooses(value)
-        if value.nil?
-          redis.del key("participant:#{identity}:show")
+        if @playground.collecting?
+          if value.nil?
+            connection.ab_not_showing @id, identity
+          else
+            index = @alternatives.index(value)
+            raise ArgumentError, "No alternative #{value.inspect} for #{name}" unless index
+            connection.ab_show @id, identity, index
+          end
         else
-          index = @alternatives.index(value)
-          raise ArgumentError, "No alternative #{value.inspect} for #{name}" unless index
-          redis[key("participant:#{identity}:show")] = index
+          @showing ||= {}
+          @showing[identity] = value.nil? ? nil : @alternatives.index(value)
         end
         self
       end
@@ -240,8 +246,12 @@ module Vanity
       # True if this alternative is currently showing (see #chooses).
       def showing?(alternative)
         identity = identity()
-        index = redis[key("participant:#{identity}:show")]
-        index && index.to_i == alternative.id
+        if @playground.collecting?
+          connection.ab_showing(@id, identity) == alternative.id
+        else
+          @showing ||= {}
+          @showing[identity] == alternative.id
+        end
       end
 
 
@@ -358,12 +368,13 @@ module Vanity
 
       # Alternative chosen when this experiment completed.
       def outcome
-        outcome = redis[key("outcome")]
-        outcome && alternatives[outcome.to_i]
+        return unless @playground.collecting?
+        outcome = connection.ab_get_outcome(@id)
+        outcome && _alternatives[outcome]
       end
 
       def complete!
-        return unless active?
+        return unless @playground.collecting? && active?
         super
         if @outcome_is
           begin
@@ -377,24 +388,20 @@ module Vanity
           outcome = best.id if best
         end
         # TODO: logging
-        redis.setnx key("outcome"), outcome || 0
+        connection.ab_set_outcome @id, outcome || 0
       end
 
       
       # -- Store/validate --
 
       def destroy
-        @alternatives.size.times do |i|
-          redis.del key("alts:#{i}:participants")
-          redis.del key("alts:#{i}:converted")
-          redis.del key("alts:#{i}:conversions")
-        end
-        redis.del key(:outcome)
+        connection.destroy_experiment @id
         super
       end
 
       def save
-        fail "Experiment #{name} needs at least two alternatives" unless alternatives.size >= 2
+        true_false unless @alternatives
+        fail "Experiment #{name} needs at least two alternatives" unless @alternatives.size >= 2
         super
         if @metrics.nil? || @metrics.empty?
           warn "Please use metrics method to explicitly state which metric you are measuring against."
@@ -411,10 +418,9 @@ module Vanity
         return unless active?
         identity = identity() rescue nil
         if identity
-          return if redis[key("participants:#{identity}:show")]
+          return if connection.ab_showing(@id, identity)
           index = alternative_for(identity)
-          redis.sadd key("alts:#{index}:converted"), identity if redis.sismember(key("alts:#{index}:participants"), identity)
-          redis.incrby key("alts:#{index}:conversions"), count
+          connection.ab_add_conversion @id, index, identity, count
           check_completion!
         end
       end
@@ -432,13 +438,12 @@ module Vanity
           participants.times do |identity|
             index = @alternatives.index(value)
             raise ArgumentError, "No alternative #{value.inspect} for #{name}" unless index
-            redis.sadd key("alts:#{index}:participants"), identity
+            connection.ab_add_participant @id, index, "#{index}:#{identity}"
           end
           conversions.times do |identity|
             index = @alternatives.index(value)
             raise ArgumentError, "No alternative #{value.inspect} for #{name}" unless index
-            redis.sadd key("alts:#{index}:converted"), identity
-            redis.incr key("alts:#{index}:conversions")
+            connection.ab_add_conversion @id, index, "#{index}:#{identity}"
           end
         end
       end

data/lib/vanity/experiment/base.rb

@@ -68,7 +68,6 @@ module Vanity
         @playground = playground
         @id, @name = id.to_sym, name
         @options = options || {}
-        @namespace = "#{@playground.namespace}:#{@id}"
         @identify_block = method(:default_identify)
       end
 
@@ -139,35 +138,35 @@ module Vanity
 
       # Force experiment to complete.
       def complete!
-        redis.setnx key(:completed_at), Time.now.to_i
-        @completed_at = redis[key(:completed_at)]
         @playground.logger.info "vanity: completed experiment #{id}"
+        return unless @playground.collecting?
+        connection.set_experiment_completed_at @id, Time.now
+        @completed_at = connection.get_experiment_completed_at(@id)
       end
 
       # Time stamp when experiment was completed.
       def completed_at
-        @completed_at ||= redis[key(:completed_at)]
-        @completed_at && Time.at(@completed_at.to_i)
+        @completed_at ||= connection.get_experiment_completed_at(@id)
       end
       
       # Returns true if experiment active, false if completed.
       def active?
-        !redis.exists(key(:completed_at))
+        !@playground.collecting? || !connection.is_experiment_completed?(@id)
       end
 
       # -- Store/validate --
 
       # Get rid of all experiment data.
       def destroy
-        redis.del key(:created_at)
-        redis.del key(:completed_at)
+        connection.destroy_experiment @id
         @created_at = @completed_at = nil
       end
 
       # Called by Playground to save the experiment definition.
       def save
-        redis.setnx key(:created_at), Time.now.to_i
-        @created_at = Time.at(redis[key(:created_at)].to_i)
+        return unless @playground.collecting?
+        connection.set_experiment_created_at @id, Time.now
+        @created_at = connection.get_experiment_created_at(@id)
       end
 
     protected
@@ -199,15 +198,14 @@ module Vanity
       #   key => "vanity:experiments:green_button"
       #   key("participants") => "vanity:experiments:green_button:participants"
       def key(name = nil)
-        name ? "#{@namespace}:#{name}" : @namespace
+        "#{@id}:#{name}"
       end
 
-      # Shortcut for Vanity.playground.redis
-      def redis
-        @playground.redis
+      # Shortcut for Vanity.playground.connection
+      def connection
+        @playground.connection
       end
       
     end
   end
 end
-

data/lib/vanity/frameworks/rails.rb

@@ -193,14 +193,10 @@ if defined?(Rails)
     # Use Rails logger by default.
     Vanity.playground.logger ||= Rails.logger
     Vanity.playground.load_path = Rails.root + Vanity.playground.load_path
-    config_file = Rails.root + "config/redis.yml"
-    if !Vanity.playground.connected? && config_file.exist?
-      config = YAML.load_file(config_file)[Rails.env.to_s]
-      Vanity.playground.redis = config if config
-    end
+    Vanity.playground.collecting = Rails.env.production?
 
-    # Do this at the very end of initialization, allowing test environment to do
-    # Vanity.playground.mock! before any database access takes place.
+    # Do this at the very end of initialization, allowing you to change
+    # connection adapter, turn collection on/off, etc.
     Rails.configuration.after_initialize do
       Vanity.playground.load!
     end
@@ -213,9 +209,9 @@ if defined?(PhusionPassenger)
   PhusionPassenger.on_event(:starting_worker_process) do |forked| 
     if forked 
       begin
-        Vanity.playground.reconnect!
+        Vanity.playground.establish_connection if Vanity.playground.collecting?
       rescue Exception=>ex
-        Rails.logger.error "Error reconnecting Redis: #{ex.to_s}" 
+        Rails.logger.error "Error reconnecting: #{ex.to_s}" 
       end
     end 
   end 

data/lib/vanity/metric/active_record.rb

@@ -62,15 +62,21 @@ module Vanity
       end
 
       # This track! method stores nothing, but calls the hooks.
-      def track!(*args)
-        count = args.first || 1
-        call_hooks Time.now, count if count > 0
+      def track!(args = nil)
+        return unless @playground.collecting?
+        call_hooks *track_args(args)
+      end
+
+      def last_update_at
+        record = @ar_scoped.find(:first, :order=>"#@ar_timestamp DESC", :limit=>1, :select=>@ar_timestamp)
+        record && record.send(@ar_timestamp)
       end
 
       # AR model after_create callback notifies all the hooks.
       def after_create(record)
+        return unless @playground.collecting?
         count = @ar_column ? (record.send(@ar_column) || 0) : 1
-        call_hooks record.send(@ar_timestamp), count if count > 0 && @ar_scoped.exists?(record)
+        call_hooks record.send(@ar_timestamp), nil, [count] if count > 0 && @ar_scoped.exists?(record)
       end
     end
   end

data/lib/vanity/metric/base.rb

@@ -4,9 +4,9 @@ module Vanity
   # can also respond to addition methods (+track!+, +bounds+, etc), these are
   # optional.
   #
-  # This class implements a basic metric that tracks data and stores it in
-  # Redis.  You can use this as the basis for your metric, or as reference for
-  # the methods your metric must and can implement.
+  # This class implements a basic metric that tracks data and stores it in the
+  # database.  You can use this as the basis for your metric, or as reference
+  # for the methods your metric must and can implement.
   #
   # @since 1.1.0
   class Metric
@@ -121,23 +121,42 @@ module Vanity
       @playground, @name = playground, name.to_s
       @id = (id || name.to_s.downcase.gsub(/\W+/, '_')).to_sym
       @hooks = []
-      redis.setnx key(:created_at), Time.now.to_i
-      @created_at = Time.at(redis[key(:created_at)].to_i)
     end
 
 
     # -- Tracking --
 
-    # Called to track an action associated with this metric.
-    def track!(count = 1)
-      count ||= 1
-      if count > 0
-        timestamp = Time.now
-        redis.incrby key(timestamp.to_date, "count"), count
-        @playground.logger.info "vanity: #{@id} with count #{count}"
-        call_hooks timestamp, count
+    # Called to track an action associated with this metric. Most common is not
+    # passing an argument, and it tracks a count of 1. You can pass a different
+    # value as the argument, or array of value (for multi-series metrics), or
+    # hash with the optional keys timestamp, identity and values.
+    #
+    # Example:
+    #   hits.track!
+    #   foo_and_bar.track! [5,11]
+    def track!(args = nil)
+      return unless @playground.collecting?
+      timestamp, identity, values = track_args(args)
+      connection.metric_track @id, timestamp, identity, values
+      @playground.logger.info "vanity: #{@id} with value #{values.join(", ")}"
+      call_hooks timestamp, identity, values
+    end
+
+    # Parses arguments to track! method and return array with timestamp,
+    # identity and array of values.
+    def track_args(args)
+      case args
+      when Hash
+        timestamp, identity, values = args.values_at(:timestamp, :identity, :values)
+      when Array
+        values = args
+      when Numeric
+        values = [args]
       end
+        identity = Vanity.context.vanity_identity rescue nil
+      [timestamp || Time.now, identity, values || [1]]
     end
+    protected :track_args
 
     # Metric definitions use this to introduce tracking hook.  The hook is
     # called with metric identifier, timestamp, count and possibly additional
@@ -172,9 +191,6 @@ module Vanity
     attr_reader :name
     alias :to_s :name
 
-    # Time stamp when metric was created.
-    attr_reader :created_at
-
     # Human readable description.  Use two newlines to break paragraphs.
     attr_accessor :description
 
@@ -192,28 +208,35 @@ module Vanity
     # Given two arguments, a start date and an end date (inclusive), returns an
     # array of measurements.  All metrics must implement this method.
     def values(from, to)
-      redis.mget((from.to_date..to.to_date).map { |date| key(date, "count") }).map(&:to_i)
+      values = connection.metric_values(@id, from, to)
+      values.map { |row| row.first.to_i }
+    end
+
+    # Returns date/time of the last update to this metric.
+    #
+    # @since 1.4.0
+    def last_update_at
+      connection.get_metric_last_update_at(@id)
     end
 
 
     # -- Storage --
 
     def destroy!
-      redis.del redis.keys(key("*"))
+      connection.destroy_metric @id
     end
 
-    def redis
-      @playground.redis
+    def connection
+      @playground.connection
     end
 
     def key(*args)
       "metrics:#{@id}:#{args.join(':')}"
     end
 
-    def call_hooks(timestamp, count)
-      count ||= 1
+    def call_hooks(timestamp, identity, values)
       @hooks.each do |hook|
-        hook.call @id, timestamp, count
+        hook.call @id, timestamp, values.first || 1
       end
     end