Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
vanity/lib/vanity/adapters/active_record_adapter.rb
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
325 lines (273 sloc)
11.8 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
module Vanity | |
module Adapters | |
class << self | |
# Creates new ActiveRecord connection and returns ActiveRecordAdapter. | |
def active_record_connection(spec) | |
require "active_record" | |
ActiveRecordAdapter.new(spec) | |
end | |
end | |
# ActiveRecord adapter | |
class ActiveRecordAdapter < AbstractAdapter | |
# Base model, stores connection and defines schema | |
class VanityRecord < ActiveRecord::Base | |
self.abstract_class = true | |
def self.needs_attr_accessible? | |
respond_to?(:attr_accessible) && (!defined?(ActionController::StrongParameters) || defined?(ProtectedAttributes)) | |
end | |
def self.rails_agnostic_find_or_create_by(method, value) | |
retried = false | |
begin | |
if respond_to? :find_or_create_by | |
find_or_create_by(method => value) | |
else | |
send :"find_or_create_by_#{method}", value | |
end | |
rescue ActiveRecord::RecordNotUnique | |
if retried # rubocop:todo Style/GuardClause | |
raise | |
else | |
retried = true | |
retry | |
end | |
end | |
end | |
end | |
# Metric model | |
class VanityMetric < VanityRecord | |
UPDATED_AT_GRACE_PERIOD = 1.minute | |
self.table_name = :vanity_metrics | |
has_many :vanity_metric_values | |
attr_accessible :metric_id if needs_attr_accessible? | |
def self.retrieve(metric) | |
rails_agnostic_find_or_create_by(:metric_id, metric.to_s) | |
end | |
def touch_with_grace_period | |
now = Time.now | |
self.updated_at = now if updated_before_grace_period?(now) | |
end | |
private | |
def updated_before_grace_period?(now) | |
now - updated_at >= UPDATED_AT_GRACE_PERIOD | |
end | |
end | |
# Metric value | |
class VanityMetricValue < VanityRecord | |
attr_accessible :date, :index, :value if needs_attr_accessible? | |
self.table_name = :vanity_metric_values | |
belongs_to :vanity_metric | |
end | |
# Experiment model | |
class VanityExperiment < VanityRecord | |
self.table_name = :vanity_experiments | |
has_many :vanity_conversions, dependent: :destroy | |
attr_accessible :experiment_id if needs_attr_accessible? | |
# Finds or creates the experiment | |
def self.retrieve(experiment) | |
rails_agnostic_find_or_create_by(:experiment_id, experiment.to_s) | |
end | |
def increment_conversion(alternative, count = 1) | |
record = vanity_conversions.rails_agnostic_find_or_create_by(:alternative, alternative) | |
record.class.update_counters(record.id, conversions: count) | |
end | |
end | |
# Conversion model | |
class VanityConversion < VanityRecord | |
self.table_name = :vanity_conversions | |
belongs_to :vanity_experiment | |
attr_accessible :alternative if needs_attr_accessible? | |
end | |
# Participant model | |
class VanityParticipant < VanityRecord | |
self.table_name = :vanity_participants | |
attr_accessible :experiment_id, :identity, :seen, :shown, :converted if needs_attr_accessible? | |
# Finds the participant by experiment and identity. If create is true | |
# then it will create the participant if not found. If a hash is | |
# passed then this will be passed to create if creating, or will be | |
# used to update the found participant. | |
def self.retrieve(experiment, identity, create = true, update_with = nil) | |
retried = false | |
begin | |
if record = VanityParticipant.where(experiment_id: experiment.to_s, identity: identity.to_s).first # rubocop:todo Lint/AssignmentInCondition | |
record.update(update_with) if update_with | |
elsif create | |
record = VanityParticipant.create({ experiment_id: experiment.to_s, identity: identity.to_s }.merge(update_with || {})) | |
end | |
record | |
rescue ActiveRecord::RecordNotUnique => e | |
if retried # rubocop:todo Style/GuardClause | |
raise e | |
else | |
retried = true | |
retry | |
end | |
end | |
end | |
end | |
def initialize(options) # rubocop:todo Lint/MissingSuper | |
@options = options.each_with_object({}) do |kv, h| | |
h[kv.first.to_s] = kv.last | |
end | |
if @options["active_record_adapter"] && (@options["active_record_adapter"] != "default") # rubocop:todo Style/GuardClause | |
@options["adapter"] = @options["active_record_adapter"] | |
VanityRecord.establish_connection(@options) | |
end | |
end | |
def active? | |
VanityRecord.connected? && VanityRecord.connection.active? | |
end | |
def disconnect! | |
VanityRecord.connection.disconnect! if active? | |
end | |
def reconnect! | |
VanityRecord.connection.reconnect! | |
end | |
def flushdb | |
[VanityExperiment, VanityMetric, VanityParticipant, VanityMetricValue, VanityConversion].each do |klass| | |
klass.delete_all | |
end | |
end | |
# -- Metrics -- | |
def get_metric_last_update_at(metric) | |
record = VanityMetric.find_by_metric_id(metric.to_s) | |
record && record.updated_at | |
end | |
def metric_track(metric, timestamp, _identity, values) | |
record = VanityMetric.retrieve(metric) | |
values.each_with_index do |value, index| | |
record.vanity_metric_values.create(date: timestamp.to_date.to_s, index: index, value: value) | |
end | |
record.touch_with_grace_period | |
record.save | |
end | |
def metric_values(metric, from, to) | |
connection = VanityMetric.connection | |
record = VanityMetric.retrieve(metric) | |
dates = (from.to_date..to.to_date).map(&:to_s) | |
conditions = [connection.quote_column_name('date') + ' BETWEEN ? AND ?', from.to_date, to.to_date] | |
order = connection.quote_column_name('date').to_s # rubocop:todo Lint/UselessAssignment | |
select = "sum(#{connection.quote_column_name('value')}) AS value, #{connection.quote_column_name('date')}" | |
group_by = connection.quote_column_name('date').to_s | |
values = record.vanity_metric_values.select(select).where(conditions).group(group_by) | |
dates.map do |date| | |
value = values.detect { |v| v.date == date } | |
[(value && value.value) || 0] | |
end | |
end | |
def destroy_metric(metric) | |
record = VanityMetric.find_by_metric_id(metric.to_s) | |
record && record.destroy | |
end | |
# -- Experiments -- | |
def experiment_persisted?(experiment) | |
VanityExperiment.find_by_experiment_id(experiment.to_s).present? | |
end | |
# Store when experiment was created (do not write over existing value). | |
def set_experiment_created_at(experiment, time) | |
record = VanityExperiment.find_by_experiment_id(experiment.to_s) || | |
VanityExperiment.new(experiment_id: experiment.to_s) | |
record.created_at ||= time | |
record.save | |
end | |
# Return when experiment was created. | |
def get_experiment_created_at(experiment) | |
record = VanityExperiment.retrieve(experiment) | |
record && record.created_at | |
end | |
def set_experiment_completed_at(experiment, time) | |
VanityExperiment.retrieve(experiment).update_attribute(:completed_at, time) | |
end | |
def get_experiment_completed_at(experiment) | |
VanityExperiment.retrieve(experiment).completed_at | |
end | |
# Returns true if experiment completed. | |
def is_experiment_completed?(experiment) # rubocop:todo Naming/PredicateName | |
!!VanityExperiment.retrieve(experiment).completed_at | |
end | |
def set_experiment_enabled(experiment, enabled) | |
VanityExperiment.retrieve(experiment).update_attribute(:enabled, enabled) | |
end | |
def is_experiment_enabled?(experiment) # rubocop:todo Naming/PredicateName | |
record = VanityExperiment.retrieve(experiment) | |
if Vanity.configuration.experiments_start_enabled | |
record.enabled != false | |
else | |
record.enabled == true | |
end | |
end | |
# Returns counts for given A/B experiment and alternative (by index). | |
# Returns hash with values for the keys :participants, :converted and | |
# :conversions. | |
def ab_counts(experiment, alternative) | |
record = VanityExperiment.retrieve(experiment) | |
participants = VanityParticipant.where(experiment_id: experiment.to_s, seen: alternative).count | |
converted = VanityParticipant.where(experiment_id: experiment.to_s, converted: alternative).count | |
conversions = record.vanity_conversions.where(alternative: alternative).sum(:conversions) | |
{ | |
participants: participants, | |
converted: converted, | |
conversions: conversions, | |
} | |
end | |
# Pick particular alternative (by index) to show to this particular | |
# participant (by identity). | |
def ab_show(experiment, identity, alternative) | |
VanityParticipant.retrieve(experiment, identity, true, shown: alternative) | |
end | |
# Indicates which alternative to show to this participant. See #ab_show. | |
def ab_showing(experiment, identity) | |
participant = VanityParticipant.retrieve(experiment, identity, false) | |
participant && participant.shown | |
end | |
# Cancels previously set association between identity and alternative. See | |
# #ab_show. | |
def ab_not_showing(experiment, identity) | |
VanityParticipant.retrieve(experiment, identity, true, shown: nil) | |
end | |
# Records a participant in this experiment for the given alternative. | |
def ab_add_participant(experiment, alternative, identity) | |
VanityParticipant.retrieve(experiment, identity, true, seen: alternative) | |
end | |
# Determines if a participant already has seen this alternative in this experiment. | |
def ab_seen(experiment, identity, alternative_or_id) | |
with_ab_seen_deprecation(experiment, identity, alternative_or_id) do |expt, ident, alt_id| | |
participant = VanityParticipant.retrieve(expt, ident, false) | |
participant && participant.seen == alt_id | |
end | |
end | |
# Returns the participant's seen alternative in this experiment, if it exists | |
def ab_assigned(experiment, identity) | |
participant = VanityParticipant.retrieve(experiment, identity, false) | |
participant && participant.seen | |
end | |
# Records a conversion in this experiment for the given alternative. | |
# Associates a value with the conversion (default to 1). If implicit is | |
# true, add participant if not already recorded for this experiment. If | |
# implicit is false (default), only add conversion if participant | |
# previously recorded as participating in this experiment. | |
def ab_add_conversion(experiment, alternative, identity, count = 1, implicit = false) | |
participant = VanityParticipant.retrieve(experiment, identity, false) # rubocop:todo Lint/UselessAssignment | |
VanityParticipant.retrieve(experiment, identity, implicit, converted: alternative, seen: alternative) | |
VanityExperiment.retrieve(experiment).increment_conversion(alternative, count) | |
end | |
# Returns the outcome of this experiment (if set), the index of a | |
# particular alternative. | |
def ab_get_outcome(experiment) | |
VanityExperiment.retrieve(experiment).outcome | |
end | |
# Sets the outcome of this experiment to a particular alternative. | |
def ab_set_outcome(experiment, alternative = 0) | |
VanityExperiment.retrieve(experiment).update_attribute(:outcome, alternative) | |
end | |
# Deletes all information about this experiment. | |
def destroy_experiment(experiment) | |
VanityParticipant.where(experiment_id: experiment.to_s).delete_all | |
record = VanityExperiment.find_by_experiment_id(experiment.to_s) | |
record && record.destroy | |
end | |
def to_s | |
@options.to_s | |
end | |
end | |
end | |
end |