moses-vanity 1.7.1

data/lib/vanity/adapters/mock_adapter.rb

@@ -0,0 +1,157 @@
+module Vanity
+  module Adapters
+    class << self
+      # Creates and returns new MockAdapter.
+      #
+      # @since 1.4.0
+      def mock_connection(spec)
+        MockAdapter.new(spec)
+      end
+    end
+
+    # Mock adapter. You can use this when running in test environment, staging,
+    # wherever you don't care for collecting metrics. Doesn't store anything.
+    #
+    # @since 1.4.0
+    class MockAdapter < AbstractAdapter
+      def initialize(options)
+        @metrics = @@metrics ||= {}
+        @experiments = @@experiments ||= {}
+      end
+
+      def active?
+        !!@metrics
+      end
+
+      def disconnect!
+        @metrics = nil
+        @experiments = nil
+      end
+
+      def reconnect!
+        @metrics = @@metrics
+        @experiments = @@experiments
+      end
+
+      def to_s
+        "mock:/"
+      end
+
+      def flushdb
+        @metrics.clear
+        @experiments.clear
+      end
+
+
+      # -- Metrics --
+      
+      def get_metric_last_update_at(metric)
+        @metrics[metric] && @metrics[metric][:last_update_at]
+      end
+
+      def metric_track(metric, timestamp, identity, values)
+        @metrics[metric] ||= {}
+        current = @metrics[metric][timestamp.to_date] ||= []
+        values.each_with_index do |v,i|
+          current[i] = (current[i] || 0) + v || 0
+        end
+        @metrics[metric][:last_update_at] = Time.now
+      end
+
+      def metric_values(metric, from, to)
+        hash = @metrics[metric] || {}
+        (from.to_date..to.to_date).map { |date| hash[date] || [] }
+      end
+
+      def destroy_metric(metric)
+        @metrics.delete metric
+      end
+      
+
+      # -- Experiments --
+     
+      def set_experiment_created_at(experiment, time)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:created_at] ||= time
+      end
+
+      def get_experiment_created_at(experiment)
+        @experiments[experiment] && @experiments[experiment][:created_at]
+      end
+
+      def set_experiment_completed_at(experiment, time)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:completed_at] ||= time
+      end
+
+      def get_experiment_completed_at(experiment)
+        @experiments[experiment] && @experiments[experiment][:completed_at]
+      end
+
+      def is_experiment_completed?(experiment)
+        @experiments[experiment] && @experiments[experiment][:completed_at]
+      end
+
+      def ab_counts(experiment, alternative)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:alternatives] ||= {}
+        alt = @experiments[experiment][:alternatives][alternative] ||= {}
+        { :participants => alt[:participants] ? alt[:participants].size : 0,
+          :converted    => alt[:converted] ? alt[:converted].size : 0,
+          :conversions  => alt[:conversions] || 0 }
+      end
+
+      def ab_show(experiment, identity, alternative)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:showing] ||= {}
+        @experiments[experiment][:showing][identity] = alternative
+      end
+
+      def ab_showing(experiment, identity)
+        @experiments[experiment] && @experiments[experiment][:showing] && @experiments[experiment][:showing][identity]
+      end
+
+      def ab_not_showing(experiment, identity)
+        @experiments[experiment][:showing].delete identity if @experiments[experiment] && @experiments[experiment][:showing]
+      end
+
+      def ab_add_participant(experiment, alternative, identity)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:alternatives] ||= {}
+        alt = @experiments[experiment][:alternatives][alternative] ||= {}
+        alt[:participants] ||= Set.new
+        alt[:participants] << identity
+      end
+
+      def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:alternatives] ||= {}
+        alt = @experiments[experiment][:alternatives][alternative] ||= {}
+        alt[:participants] ||= Set.new
+        alt[:converted] ||= Set.new
+        alt[:conversions] ||= 0
+        if implicit
+          alt[:participants] << identity
+        else
+          participating = alt[:participants].include?(identity) 
+        end
+        alt[:converted] << identity if implicit || participating
+        alt[:conversions] += count
+      end
+
+      def ab_get_outcome(experiment)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:outcome]
+      end
+
+      def ab_set_outcome(experiment, alternative = 0)
+        @experiments[experiment] ||= {}
+        @experiments[experiment][:outcome] = alternative
+      end
+
+      def destroy_experiment(experiment)
+        @experiments.delete experiment
+      end
+    end
+  end
+end

data/lib/vanity/adapters/mongodb_adapter.rb

@@ -0,0 +1,178 @@
+module Vanity
+  module Adapters
+    class << self
+      # Creates new connection to MongoDB and returns MongoAdapter.
+      #
+      # @since 1.4.0
+      def mongo_connection(spec)
+        require "mongo"
+        MongodbAdapter.new(spec)
+      end
+      alias :mongodb_connection :mongo_connection
+    end
+
+    # MongoDB adapter.
+    #
+    # @since 1.4.0
+    class MongodbAdapter < AbstractAdapter
+      attr_reader :mongo
+
+      def initialize(options)
+        setup_connection(options)
+        @options = options.clone
+        @options[:database] ||= (@options[:path] && @options[:path].split("/")[1]) || "vanity"
+        connect!
+      end
+
+      def setup_connection(options = {})
+        if options[:hosts]
+          args = (options[:hosts].map{|host| [host, options[:port]] } << {:connect => false})
+          @mongo = Mongo::ReplSetConnection.new(*args)
+        else
+          @mongo = Mongo::Connection.new(options[:host], options[:port], :connect => false)
+        end
+        @mongo
+      end
+
+      def active?
+        @mongo.connected?
+      end
+
+      def disconnect!
+        @mongo.close rescue nil if @mongo
+        @metrics, @experiments = nil
+        @mongo = nil
+      end
+
+      def reconnect!
+        disconnect!
+        connect!
+      end
+
+      def connect!
+        @mongo ||= setup_connection(@options)
+        @mongo.connect
+        database = @mongo.db(@options[:database])
+        database.authenticate @options[:username], @options[:password], true if @options[:username]
+        @metrics = database.collection("vanity.metrics")
+        @experiments = database.collection("vanity.experiments")
+        @participants = database.collection("vanity.participants")
+        @participants.create_index [[:experiment, 1], [:identity, 1]], :unique=>true
+        @participants.create_index [[:experiment, 1], [:seen, 1]]
+        @participants.create_index [[:experiment, 1], [:converted, 1]]
+        @mongo
+      end
+
+      def to_s
+        userinfo = @options.values_at(:username, :password).join(":") if @options[:username]
+        URI::Generic.build(:scheme=>"mongodb", :userinfo=>userinfo, :host=>(@mongo.host || @options[:host]), :port=>(@mongo.port || @options[:port]), :path=>"/#{@options[:database]}").to_s
+      end
+
+      def flushdb
+        @metrics.drop
+        @experiments.drop
+        @participants.drop
+      end
+      
+
+      # -- Metrics --
+      
+      def get_metric_last_update_at(metric)
+        record = @metrics.find_one(:_id=>metric)
+        record && record["last_update_at"]
+      end
+
+      def metric_track(metric, timestamp, identity, values)
+        inc = {}
+        values.each_with_index do |v,i|
+          inc["data.#{timestamp.to_date}.#{i}"] = v
+        end
+        @metrics.update({ :_id=>metric }, { "$inc"=>inc, "$set"=>{ :last_update_at=>Time.now } }, :upsert=>true)
+      end
+
+      def metric_values(metric, from, to)
+        record = @metrics.find_one(:_id=>metric)
+        data = record && record["data"] || {}
+        (from.to_date..to.to_date).map { |date| (data[date.to_s] || {}).values }
+      end
+
+      def destroy_metric(metric)
+        @metrics.remove :_id=>metric
+      end
+      
+
+      # -- Experiments --
+     
+      def set_experiment_created_at(experiment, time)
+        @experiments.insert :_id=>experiment, :created_at=>time
+      end
+
+      def get_experiment_created_at(experiment)
+        record = @experiments.find_one({ :_id=>experiment }, { :fields=>[:created_at] })
+        record && record["created_at"]
+      end
+
+      def set_experiment_completed_at(experiment, time)
+        @experiments.update({ :_id=>experiment }, { "$set"=>{ :completed_at=>time } }, :upsert=>true)
+      end
+
+      def get_experiment_completed_at(experiment)
+        record = @experiments.find_one({ :_id=>experiment }, { :fields=>[:completed_at] })
+        record && record["completed_at"]
+      end
+
+      def is_experiment_completed?(experiment)
+        !!@experiments.find_one(:_id=>experiment, :completed_at=>{ "$exists"=>true })
+      end
+
+      def ab_counts(experiment, alternative)
+        record = @experiments.find_one({ :_id=>experiment }, { :fields=>[:conversions] })
+        conversions = record && record["conversions"]
+        { :participants => @participants.find({ :experiment=>experiment, :seen=>alternative }).count,
+          :converted    => @participants.find({ :experiment=>experiment, :converted=>alternative }).count,
+          :conversions  => conversions && conversions[alternative.to_s] || 0 }
+      end
+
+      def ab_show(experiment, identity, alternative)
+        @participants.update({ :experiment=>experiment, :identity=>identity }, { "$set"=>{ :show=>alternative } }, :upsert=>true)
+      end
+
+      def ab_showing(experiment, identity)
+        participant = @participants.find_one({ :experiment=>experiment, :identity=>identity }, { :fields=>[:show] })
+        participant && participant["show"]
+      end
+
+      def ab_not_showing(experiment, identity)
+        @participants.update({ :experiment=>experiment, :identity=>identity }, { "$unset"=>:show })
+      end
+
+      def ab_add_participant(experiment, alternative, identity)
+        @participants.update({ :experiment=>experiment, :identity=>identity }, { "$push"=>{ :seen=>alternative } }, :upsert=>true)
+      end
+
+      def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false)
+        if implicit
+          @participants.update({ :experiment=>experiment, :identity=>identity }, { "$push"=>{ :seen=>alternative } }, :upsert=>true)
+        else
+          participating = @participants.find_one(:experiment=>experiment, :identity=>identity, :seen=>alternative)
+        end
+        @participants.update({ :experiment=>experiment, :identity=>identity }, { "$push"=>{ :converted=>alternative } }, :upsert=>true) if implicit || participating
+        @experiments.update({ :_id=>experiment }, { "$inc"=>{ "conversions.#{alternative}"=>count } }, :upsert=>true)
+      end
+
+      def ab_get_outcome(experiment)
+        experiment = @experiments.find_one({ :_id=>experiment }, { :fields=>[:outcome] })
+        experiment && experiment["outcome"]
+      end
+
+      def ab_set_outcome(experiment, alternative = 0)
+        @experiments.update({ :_id=>experiment }, { "$set"=>{ :outcome=>alternative } }, :upsert=>true)
+      end
+
+      def destroy_experiment(experiment)
+        @experiments.remove :_id=>experiment
+        @participants.remove :experiment=>experiment
+      end
+    end
+  end
+end

data/lib/vanity/adapters/redis_adapter.rb

@@ -0,0 +1,160 @@
+module Vanity
+  module Adapters
+    class << self
+      # Creates new connection to Redis and returns RedisAdapter.
+      #
+      # @since 1.4.0
+      def redis_connection(spec)
+        require "redis/namespace"
+        RedisAdapter.new(spec)
+      end
+    end
+
+    # Redis adapter.
+    #
+    # @since 1.4.0
+    class RedisAdapter < AbstractAdapter
+      def initialize(options)
+        @options = options.clone
+        @options[:db] ||= @options[:database] || (@options[:path] && @options.delete(:path).split("/")[1].to_i)
+        @options[:thread_safe] = true
+        connect!
+      end
+
+      def active?
+        !!@redis
+      end
+
+      def disconnect!
+        if redis
+          begin
+            redis.client.disconnect
+          rescue Exception => e
+            warn("Error while disconnecting from redis: #{e.message}")
+          end
+        end
+        @redis = nil
+      end
+
+      def reconnect!
+        disconnect!
+        connect!
+      end
+
+      def connect!
+        @redis = @options[:redis] || Redis.new(@options)
+        @metrics = Redis::Namespace.new("vanity:metrics", :redis=>@redis)
+        @experiments = Redis::Namespace.new("vanity:experiments", :redis=>@redis)
+      end
+
+      def to_s
+        redis.id
+      end
+
+      def redis
+        @redis
+      end
+
+      def flushdb
+        @redis.flushdb
+      end
+
+      # -- Metrics --
+      
+      def get_metric_last_update_at(metric)
+        last_update_at = @metrics["#{metric}:last_update_at"]
+        last_update_at && Time.at(last_update_at.to_i)
+      end
+
+      def metric_track(metric, timestamp, identity, values)
+        values.each_with_index do |v,i|
+          @metrics.incrby "#{metric}:#{timestamp.to_date}:value:#{i}", v
+        end
+        @metrics["#{metric}:last_update_at"] = Time.now.to_i
+      end
+
+      def metric_values(metric, from, to)
+        single = @metrics.mget(*(from.to_date..to.to_date).map { |date| "#{metric}:#{date}:value:0" }) || []
+        single.map { |v| [v] }
+      end
+
+      def destroy_metric(metric)
+        @metrics.del *@metrics.keys("#{metric}:*")
+      end
+
+
+      # -- Experiments --
+     
+      def set_experiment_created_at(experiment, time)
+        @experiments.setnx "#{experiment}:created_at", time.to_i
+      end
+
+      def get_experiment_created_at(experiment)
+        created_at = @experiments["#{experiment}:created_at"]
+        created_at && Time.at(created_at.to_i)
+      end
+
+      def set_experiment_completed_at(experiment, time)
+        @experiments.setnx "#{experiment}:completed_at", time.to_i
+      end
+
+      def get_experiment_completed_at(experiment)
+        completed_at = @experiments["#{experiment}:completed_at"]
+        completed_at && Time.at(completed_at.to_i)
+      end
+
+      def is_experiment_completed?(experiment)
+        @experiments.exists("#{experiment}:completed_at")
+      end
+
+      def ab_counts(experiment, alternative)
+        { :participants => @experiments.scard("#{experiment}:alts:#{alternative}:participants").to_i,
+          :converted    => @experiments.scard("#{experiment}:alts:#{alternative}:converted").to_i,
+          :conversions  => @experiments["#{experiment}:alts:#{alternative}:conversions"].to_i }
+      end
+
+      def ab_show(experiment, identity, alternative)
+        @experiments["#{experiment}:participant:#{identity}:show"] = alternative
+      end
+
+      def ab_showing(experiment, identity)
+        alternative = @experiments["#{experiment}:participant:#{identity}:show"]
+        alternative && alternative.to_i
+      end
+
+      def ab_not_showing(experiment, identity)
+        @experiments.del "#{experiment}:participant:#{identity}:show"
+      end
+
+      def ab_add_participant(experiment, alternative, identity)
+        @experiments.sadd "#{experiment}:alts:#{alternative}:participants", identity
+      end
+
+      def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false)
+        if implicit
+          @experiments.sadd "#{experiment}:alts:#{alternative}:participants", identity
+        else
+          participating = @experiments.sismember("#{experiment}:alts:#{alternative}:participants", identity)
+        end
+        @experiments.sadd "#{experiment}:alts:#{alternative}:converted", identity if implicit || participating
+        @experiments.incrby "#{experiment}:alts:#{alternative}:conversions", count
+      end
+
+      def ab_get_outcome(experiment)
+        alternative = @experiments["#{experiment}:outcome"]
+        alternative && alternative.to_i
+      end
+
+      def ab_set_outcome(experiment, alternative = 0)
+        @experiments.setnx "#{experiment}:outcome", alternative
+      end
+
+      def destroy_experiment(experiment)
+        @experiments.del "#{experiment}:outcome", "#{experiment}:created_at", "#{experiment}:completed_at"
+        alternatives = @experiments.keys("#{experiment}:alts:*")
+        @experiments.del *alternatives unless alternatives.empty?
+      end
+
+    end
+  end
+end