test_track_rails_client 0.9.0

data/app/models/test_track/offline_session.rb

@@ -0,0 +1,46 @@
+class TestTrack::OfflineSession
+  def initialize(identifier_type, identifier_value)
+    @identifier_type = identifier_type
+    @identifier_value = identifier_value
+  end
+
+  def self.with_visitor_for(identifier_type, identifier_value)
+    raise ArgumentError, "must provide block to `with_visitor_for`" unless block_given?
+
+    new(identifier_type, identifier_value).send :manage do |visitor_dsl|
+      yield visitor_dsl
+    end
+  end
+
+  private
+
+  attr_reader :identifier_type, :identifier_value
+
+  def visitor
+    @visitor ||= TestTrack::Visitor.new(
+      id: remote_visitor.id,
+      assignments: remote_visitor.assignments
+    )
+  end
+
+  def remote_visitor
+    @remote_visitor ||= TestTrack::Remote::Visitor.from_identifier(identifier_type, identifier_value)
+  end
+
+  def manage
+    yield TestTrack::VisitorDSL.new(visitor)
+  ensure
+    notify_unsynced_assignments! if unsynced_assignments?
+  end
+
+  def unsynced_assignments?
+    visitor.unsynced_assignments.present?
+  end
+
+  def notify_unsynced_assignments!
+    TestTrack::UnsyncedAssignmentsNotifier.new(
+      visitor_id: visitor.id,
+      assignments: visitor.unsynced_assignments
+    ).notify
+  end
+end

data/app/models/test_track/remote/assignment.rb

@@ -0,0 +1,20 @@
+class TestTrack::Remote::Assignment
+  include TestTrack::RemoteModel
+
+  attributes :visitor_id, :split_name, :variant, :unsynced
+
+  validates :visitor_id, :split_name, :variant, :mixpanel_result, presence: true
+
+  def unsynced?
+    unsynced || variant_changed?
+  end
+
+  def self.fake_instance_attributes(id)
+    {
+      split_name: "split_#{id}",
+      variant: "true",
+      context: "context",
+      unsynced: false
+    }
+  end
+end

data/app/models/test_track/remote/assignment_event.rb

@@ -0,0 +1,15 @@
+class TestTrack::Remote::AssignmentEvent
+  include TestTrack::RemoteModel
+
+  collection_path '/api/v1/assignment_event'
+
+  attributes :visitor_id, :split_name, :unsynced
+
+  validates :visitor_id, :split_name, :mixpanel_result, presence: true
+
+  alias unsynced? unsynced
+
+  def fake_save_response_attributes
+    nil # :no_content is the expected response type
+  end
+end

data/app/models/test_track/remote/fake_server.rb

@@ -0,0 +1,8 @@
+class TestTrack::Remote::FakeServer
+  include TestTrack::RemoteModel
+
+  def self.reset!(seed)
+    raise('Cannot reset FakeServer if TestTrack is enabled.') if TestTrack.enabled?
+    put('api/v1/reset', seed: seed)
+  end
+end

data/app/models/test_track/remote/identifier.rb

@@ -0,0 +1,26 @@
+class TestTrack::Remote::Identifier
+  include TestTrack::RemoteModel
+
+  collection_path '/api/v1/identifier'
+
+  has_one :remote_visitor, data_key: :visitor, class_name: "TestTrack::Remote::Visitor"
+
+  attributes :identifier_type, :visitor_id, :value
+
+  validates :identifier_type, :visitor_id, :value, presence: true
+
+  def fake_save_response_attributes
+    { visitor: { id: visitor_id, assignments: [] } }
+  end
+
+  def visitor
+    @visitor ||= TestTrack::Visitor.new(visitor_opts!)
+  end
+
+  private
+
+  def visitor_opts!
+    raise("Visitor data unavailable until you save this identifier.") unless attributes[:remote_visitor]
+    { id: remote_visitor.id, assignments: remote_visitor.assignments }
+  end
+end

data/app/models/test_track/remote/identifier_type.rb

@@ -0,0 +1,13 @@
+class TestTrack::Remote::IdentifierType
+  include TestTrack::RemoteModel
+
+  collection_path '/api/v1/identifier_type'
+
+  attributes :name
+
+  validates :name, presence: true
+
+  def fake_save_response_attributes
+    nil # :no_content is the expected response type
+  end
+end

data/app/models/test_track/remote/split_config.rb

@@ -0,0 +1,13 @@
+class TestTrack::Remote::SplitConfig
+  include TestTrack::RemoteModel
+
+  collection_path '/api/v1/split_configs'
+
+  attributes :name, :weighting_registry
+
+  validates :name, :weighting_registry, presence: true
+
+  def fake_save_response_attributes
+    nil # :no_content is the expected response type
+  end
+end

data/app/models/test_track/remote/split_registry.rb

@@ -0,0 +1,36 @@
+class TestTrack::Remote::SplitRegistry
+  include TestTrack::RemoteModel
+
+  CACHE_KEY = 'test_track_split_registry'.freeze
+
+  collection_path '/api/v1/split_registry'
+
+  def self.fake_instance_attributes(_)
+    ::TestTrack::Fake::SplitRegistry.instance.to_h
+  end
+
+  def self.instance
+    # TODO: FakeableHer needs to make this faking a feature of `get`
+    if faked?
+      new(fake_instance_attributes(nil))
+    else
+      get('/api/v1/split_registry')
+    end
+  end
+
+  def self.reset
+    Rails.cache.delete(CACHE_KEY)
+  end
+
+  def self.to_hash
+    if faked?
+      instance.attributes.freeze
+    else
+      Rails.cache.fetch(CACHE_KEY, expires_in: 5.seconds) do
+        instance.attributes
+      end.freeze
+    end
+  rescue *TestTrack::SERVER_ERRORS
+    nil # if we can't get a split registry
+  end
+end

data/app/models/test_track/remote/visitor.rb

@@ -0,0 +1,29 @@
+class TestTrack::Remote::Visitor
+  include TestTrack::RemoteModel
+
+  collection_path '/api/v1/visitors'
+
+  has_many :assignments
+
+  def self.from_identifier(identifier_type, identifier_value)
+    raise "must provide an identifier_type" unless identifier_type.present?
+    raise "must provide an identifier_value" unless identifier_value.present?
+
+    # TODO: FakeableHer needs to make this faking a feature of `get`
+    if faked?
+      new(fake_instance_attributes(nil))
+    else
+      get("/api/v1/identifier_types/#{identifier_type}/identifiers/#{identifier_value}/visitor")
+    end
+  end
+
+  def self.fake_instance_attributes(_)
+    {
+      id: "fake_visitor_id",
+      assignments: [
+        TestTrack::Remote::Assignment.fake_instance_attributes(1),
+        TestTrack::Remote::Assignment.fake_instance_attributes(2)
+      ]
+    }
+  end
+end

data/app/models/test_track/session.rb

@@ -0,0 +1,167 @@
+require 'delayed_job'
+require 'delayed_job_active_record'
+
+class TestTrack::Session
+  COOKIE_LIFESPAN = 1.year # Used for tt_visitor_id cookie
+
+  def initialize(controller)
+    @controller = controller
+  end
+
+  def manage
+    yield
+  ensure
+    manage_cookies!
+    notify_unsynced_assignments! if sync_assignments?
+    create_alias! if signed_up?
+  end
+
+  def visitor_dsl
+    @visitor_dsl ||= TestTrack::VisitorDSL.new(visitor)
+  end
+
+  def state_hash
+    {
+      url: TestTrack.url,
+      cookieDomain: cookie_domain,
+      registry: visitor.split_registry,
+      assignments: visitor.assignment_json
+    }
+  end
+
+  def log_in!(identifier_type, identifier_value, opts = {})
+    @visitor = TestTrack::Visitor.new if opts[:forget_current_visitor]
+    visitor.link_identifier!(identifier_type, identifier_value)
+    self.mixpanel_distinct_id = visitor.id
+    true
+  end
+
+  def sign_up!(identifier_type, identifier_value)
+    visitor.link_identifier!(identifier_type, identifier_value)
+    @signed_up = true
+  end
+
+  private
+
+  attr_reader :controller, :signed_up
+  alias signed_up? signed_up
+
+  def visitor
+    @visitor ||= TestTrack::Visitor.new(id: cookies[:tt_visitor_id])
+  end
+
+  def set_cookie(name, value)
+    cookies[name] = {
+      value: value,
+      domain: cookie_domain,
+      secure: request.ssl?,
+      httponly: false,
+      expires: COOKIE_LIFESPAN.from_now
+    }
+  end
+
+  def cookie_domain
+    @cookie_domain ||= _cookie_domain
+  end
+
+  def _cookie_domain
+    if bare_ip_address?
+      request.host
+    elsif TestTrack.fully_qualified_cookie_domain_enabled?
+      fully_qualified_domain
+    else
+      wildcard_domain
+    end
+  end
+
+  def bare_ip_address?
+    request.host.match(Resolv::AddressRegex)
+  end
+
+  def fully_qualified_domain
+    public_suffix_host.name
+  end
+
+  def wildcard_domain
+    "." + public_suffix_host.domain
+  end
+
+  def public_suffix_host
+    @public_suffix_host ||= PublicSuffix.parse(request.host)
+  end
+
+  def manage_cookies!
+    set_cookie(mixpanel_cookie_name, mixpanel_cookie.to_json)
+    set_cookie(:tt_visitor_id, visitor.id)
+  end
+
+  def request
+    controller.request
+  end
+
+  def cookies
+    controller.send(:cookies)
+  end
+
+  def notify_unsynced_assignments!
+    payload = {
+      mixpanel_distinct_id: mixpanel_distinct_id,
+      visitor_id: visitor.id,
+      assignments: visitor.unsynced_assignments
+    }
+    ActiveSupport::Notifications.instrument('test_track.notify_unsynced_assignments', payload) do
+      ##
+      # This block creates an unbounded number of threads up to 1 per request.
+      # This can potentially cause issues under high load, in which case we should move to a thread pool/work queue.
+      Thread.new do
+        TestTrack::UnsyncedAssignmentsNotifier.new(payload).notify
+      end
+    end
+  end
+
+  def create_alias!
+    create_alias_job = TestTrack::CreateAliasJob.new(
+      existing_id: mixpanel_distinct_id,
+      alias_id: visitor.id
+    )
+    Delayed::Job.enqueue(create_alias_job)
+  end
+
+  def sync_assignments?
+    !visitor.offline? && visitor.unsynced_assignments.present?
+  end
+
+  def mixpanel_distinct_id
+    mixpanel_cookie['distinct_id']
+  end
+
+  def mixpanel_distinct_id=(value)
+    mixpanel_cookie['distinct_id'] = value
+  end
+
+  def mixpanel_cookie
+    @mixpanel_cookie ||= read_mixpanel_cookie || generate_mixpanel_cookie
+  end
+
+  def read_mixpanel_cookie
+    mixpanel_cookie = cookies[mixpanel_cookie_name]
+    begin
+      JSON.parse(mixpanel_cookie) if mixpanel_cookie
+    rescue JSON::ParserError
+      Rails.logger.error("malformed mixpanel JSON from cookie #{URI.unescape(mixpanel_cookie)}")
+      nil
+    end
+  end
+
+  def generate_mixpanel_cookie
+    { 'distinct_id' => visitor.id }
+  end
+
+  def mixpanel_token
+    ENV['MIXPANEL_TOKEN'] || raise("ENV['MIXPANEL_TOKEN'] must be set")
+  end
+
+  def mixpanel_cookie_name
+    "mp_#{mixpanel_token}_mixpanel"
+  end
+end

data/app/models/test_track/unsynced_assignments_notifier.rb

@@ -0,0 +1,36 @@
+class TestTrack::UnsyncedAssignmentsNotifier
+  attr_reader :mixpanel_distinct_id, :visitor_id, :assignments
+
+  def initialize(opts)
+    @visitor_id = opts.delete(:visitor_id)
+    @mixpanel_distinct_id = opts.delete(:mixpanel_distinct_id) || visitor_id
+    @assignments = opts.delete(:assignments)
+
+    %w(visitor_id assignments).each do |param_name|
+      raise "#{param_name} must be present" unless send(param_name).present?
+    end
+    raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+  end
+
+  def notify
+    assignments.each do |assignment|
+      build_notify_assignment_job(assignment).tap do |job|
+        begin
+          job.perform
+        rescue *TestTrack::SERVER_ERRORS
+          Delayed::Job.enqueue(build_notify_assignment_job(assignment))
+        end
+      end
+    end
+  end
+
+  private
+
+  def build_notify_assignment_job(assignment)
+    TestTrack::NotifyAssignmentJob.new(
+      mixpanel_distinct_id: mixpanel_distinct_id,
+      visitor_id: visitor_id,
+      assignment: assignment
+    )
+  end
+end

data/app/models/test_track/variant_calculator.rb

@@ -0,0 +1,48 @@
+require 'digest'
+
+class TestTrack::VariantCalculator
+  include TestTrack::RequiredOptions
+
+  attr_reader :visitor, :split_name
+
+  delegate :split_registry, to: :visitor
+
+  def initialize(opts = {})
+    @visitor = require_option!(opts, :visitor)
+    @split_name = require_option!(opts, :split_name)
+    raise "unknown opts: #{opts.keys.to_sentence}" if opts.present?
+  end
+
+  def variant
+    return nil unless split_registry
+    @variant ||= _variant || raise("Assignment bucket out of range. #{assignment_bucket} unmatched in #{split_name}: #{weighting}")
+  end
+
+  def _variant
+    bucket_ceiling = 0
+    sorted_variants.detect do |variant|
+      bucket_ceiling += weighting[variant]
+      bucket_ceiling > assignment_bucket
+    end
+  end
+
+  def sorted_variants
+    weighting.keys.sort
+  end
+
+  def weighting
+    @weighting ||= split_registry[split_name] || raise("TestTrack split '#{split_name}' not found. Need to write/run a migration?")
+  end
+
+  def assignment_bucket
+    @assignment_bucket ||= hash_fixnum % 100
+  end
+
+  def hash_fixnum
+    split_visitor_hash.slice(0, 8).to_i(16)
+  end
+
+  def split_visitor_hash
+    Digest::MD5.new.update(split_name.to_s + visitor.id.to_s).hexdigest
+  end
+end