ahoy_matey 1.6.1 → 2.0.0

data/lib/ahoy.rb

@@ -1,53 +1,21 @@
 require "active_support"
 require "active_support/core_ext"
 require "addressable/uri"
-require "browser"
 require "geocoder"
-require "referer-parser"
-require "user_agent_parser"
-require "request_store"
-require "uuidtools"
 require "safely/core"
 
-require "ahoy/version"
-require "ahoy/tracker"
+require "ahoy/base_store"
 require "ahoy/controller"
+require "ahoy/database_store"
 require "ahoy/model"
+require "ahoy/query_methods"
+require "ahoy/tracker"
+require "ahoy/version"
 require "ahoy/visit_properties"
-require "ahoy/properties"
-require "ahoy/deckhands/location_deckhand"
-require "ahoy/deckhands/request_deckhand"
-require "ahoy/deckhands/technology_deckhand"
-require "ahoy/deckhands/traffic_source_deckhand"
-require "ahoy/deckhands/utm_parameter_deckhand"
-require "ahoy/stores/base_store"
-require "ahoy/stores/active_record_store"
-require "ahoy/stores/active_record_token_store"
-require "ahoy/stores/log_store"
-require "ahoy/stores/fluentd_store"
-require "ahoy/stores/mongoid_store"
-require "ahoy/stores/kafka_store"
-require "ahoy/stores/nats_store"
-require "ahoy/stores/nsq_store"
-require "ahoy/stores/kinesis_firehose_store"
-require "ahoy/stores/bunny_store"
-require "ahoy/engine" if defined?(Rails)
-require "ahoy/warden" if defined?(Warden)
-
-# background jobs
-begin
-  require "active_job"
-rescue LoadError
-  # do nothing
-end
-require "ahoy/geocode_job" if defined?(ActiveJob)
 
-# deprecated
-require "ahoy/subscribers/active_record"
+require "ahoy/engine" if defined?(Rails)
 
 module Ahoy
-  UUID_NAMESPACE = UUIDTools::UUID.parse("a82ae811-5011-45ab-a728-569df7499c5f")
-
   mattr_accessor :visit_duration
   self.visit_duration = 4.hours
 
@@ -56,8 +24,8 @@ module Ahoy
 
   mattr_accessor :cookie_domain
 
-  mattr_accessor :track_visits_immediately
-  self.track_visits_immediately = false
+  mattr_accessor :server_side_visits
+  self.server_side_visits = true
 
   mattr_accessor :quiet
   self.quiet = true
@@ -71,70 +39,44 @@ module Ahoy
   mattr_accessor :max_events_per_request
   self.max_events_per_request = 10
 
-  mattr_accessor :mount
-  self.mount = true
-
-  mattr_accessor :throttle
-  self.throttle = true
-
-  mattr_accessor :throttle_limit
-  self.throttle_limit = 20
-
-  mattr_accessor :throttle_period
-  self.throttle_period = 1.minute
-
   mattr_accessor :job_queue
   self.job_queue = :ahoy
 
+  mattr_accessor :api
+  self.api = false
+
   mattr_accessor :api_only
   self.api_only = false
 
   mattr_accessor :protect_from_forgery
-  self.protect_from_forgery = false
-
-  def self.ensure_uuid(id)
-    valid = UUIDTools::UUID.parse(id) rescue nil
-    if valid
-      id
-    else
-      UUIDTools::UUID.sha1_create(UUID_NAMESPACE, id).to_s
-    end
-  end
+  self.protect_from_forgery = true
 
-  # deprecated
+  mattr_accessor :preserve_callbacks
+  self.preserve_callbacks = [:load_authlogic, :activate_authlogic]
 
-  mattr_accessor :domain
-  mattr_accessor :visit_model
   mattr_accessor :user_method
-  mattr_accessor :exclude_method
+  self.user_method = lambda do |controller|
+    (controller.respond_to?(:current_user) && controller.current_user) || (controller.respond_to?(:current_resource_owner, true) && controller.send(:current_resource_owner)) || nil
+  end
 
-  mattr_accessor :subscribers
-  self.subscribers = []
+  mattr_accessor :exclude_method
 
   mattr_accessor :track_bots
   self.track_bots = false
+
+  mattr_accessor :token_generator
+  self.token_generator = -> { SecureRandom.uuid }
 end
 
-if defined?(Rails)
-  ActiveSupport.on_load(:action_controller) do
-    include Ahoy::Controller
-  end
+ActiveSupport.on_load(:action_controller) do
+  include Ahoy::Controller
+end
 
-  ActiveSupport.on_load(:active_record) do
-    extend Ahoy::Model
-  end
+ActiveSupport.on_load(:active_record) do
+  extend Ahoy::Model
+end
 
-  # ensure logger silence will not be added by activerecord-session_store
-  # otherwise, we get SystemStackError: stack level too deep
-  begin
-    require "active_record/session_store/extension/logger_silencer"
-  rescue LoadError
-    require "ahoy/logger_silencer"
-    Logger.send :include, Ahoy::LoggerSilencer
-
-    begin
-      require "syslog/logger"
-      Syslog::Logger.send :include, Ahoy::LoggerSilencer
-    rescue LoadError; end
-  end
+# Mongoid
+if defined?(ActiveModel)
+  ActiveModel::Callbacks.include(Ahoy::Model)
 end

data/lib/ahoy/base_store.rb

@@ -0,0 +1,72 @@
+module Ahoy
+  class BaseStore
+    attr_writer :user
+
+    def initialize(options)
+      @options = options
+    end
+
+    def track_visit(data)
+    end
+
+    def track_event(data)
+    end
+
+    def geocode(data)
+    end
+
+    def authenticate(data)
+    end
+
+    def visit
+    end
+
+    def user
+      @user ||= begin
+        if Ahoy.user_method.respond_to?(:call)
+          Ahoy.user_method.call(controller)
+        else
+          controller.send(Ahoy.user_method)
+        end
+      end
+    end
+
+    def exclude?
+      (!Ahoy.track_bots && bot?) || exclude_by_method?
+    end
+
+    def generate_id
+      Ahoy.token_generator.call
+    end
+
+    protected
+
+    def bot?
+      @bot ||= request ? Browser.new(request.user_agent).bot? : false
+    end
+
+    def exclude_by_method?
+      if Ahoy.exclude_method
+        if Ahoy.exclude_method.arity == 1
+          Ahoy.exclude_method.call(controller)
+        else
+          Ahoy.exclude_method.call(controller, request)
+        end
+      else
+        false
+      end
+    end
+
+    def request
+      @request ||= @options[:request] || controller.try(:request)
+    end
+
+    def controller
+      @controller ||= @options[:controller]
+    end
+
+    def ahoy
+      @ahoy ||= @options[:ahoy]
+    end
+  end
+end

data/lib/ahoy/controller.rb

@@ -7,15 +7,9 @@ module Ahoy
         base.helper_method :current_visit
         base.helper_method :ahoy
       end
-      if base.respond_to?(:before_action)
-        base.before_action :set_ahoy_cookies, unless: -> { Ahoy.api_only }
-        base.before_action :track_ahoy_visit, unless: -> { Ahoy.api_only }
-        base.before_action :set_ahoy_request_store
-      else
-        base.before_filter :set_ahoy_cookies, unless: -> { Ahoy.api_only }
-        base.before_filter :track_ahoy_visit, unless: -> { Ahoy.api_only }
-        base.before_filter :set_ahoy_request_store
-      end
+      base.before_action :set_ahoy_cookies, unless: -> { Ahoy.api_only }
+      base.before_action :track_ahoy_visit, unless: -> { Ahoy.api_only }
+      base.before_action :set_ahoy_request_store
     end
 
     def ahoy
@@ -33,7 +27,7 @@ module Ahoy
 
     def track_ahoy_visit
       if ahoy.new_visit?
-        ahoy.track_visit(defer: !Ahoy.track_visits_immediately)
+        ahoy.track_visit(defer: !Ahoy.server_side_visits)
       end
     end
 

data/lib/ahoy/database_store.rb

@@ -0,0 +1,72 @@
+module Ahoy
+  class DatabaseStore < BaseStore
+    def track_visit(data)
+      @visit = visit_model.create!(slice_data(visit_model, data))
+    rescue => e
+      raise e unless unique_exception?(e)
+      @visit = nil
+    end
+
+    def track_event(data)
+      # if we don't have a visit, let's try to create one first
+      ahoy.track_visit unless visit
+
+      event = event_model.new(slice_data(event_model, data))
+      event.visit = visit
+      begin
+        event.save!
+      rescue => e
+        raise e unless unique_exception?(e)
+      end
+    end
+
+    def geocode(data)
+      data = slice_data(visit_model, data.except(:visit_token))
+      if defined?(Mongoid::Document) && visit_model < Mongoid::Document
+        # upsert since visit might not be found due to eventual consistency
+        visit_model.where(visit_token: ahoy.visit_token).find_one_and_update({"$set": data}, {upsert: true})
+      elsif visit
+        visit.update_attributes(data)
+      else
+        $stderr.puts "[ahoy] Visit for geocode not found: #{data[:visit_token]}"
+      end
+    end
+
+    def authenticate(_)
+      if visit && visit.respond_to?(:user) && !visit.user
+        begin
+          visit.user = user
+          visit.save!
+        rescue ActiveRecord::AssociationTypeMismatch
+          # do nothing
+        end
+      end
+    end
+
+    def visit
+      @visit ||= visit_model.where(visit_token: ahoy.visit_token).first if ahoy.visit_token
+    end
+
+    protected
+
+    def visit_model
+      ::Ahoy::Visit
+    end
+
+    def event_model
+      ::Ahoy::Event
+    end
+
+    def slice_data(model, data)
+      column_names = model.try(:column_names) || model.attribute_names
+      data.slice(*column_names.map(&:to_sym)).select { |_, v| v }
+    end
+
+    def unique_exception?(e)
+      return true if defined?(ActiveRecord::RecordNotUnique) && e.is_a?(ActiveRecord::RecordNotUnique)
+      return true if defined?(PG::UniqueViolation) && e.is_a?(PG::UniqueViolation)
+      return true if defined?(Mongo::Error::OperationFailure) && e.is_a?(Mongo::Error::OperationFailure) && e.message.include?("duplicate key error")
+      false
+    end
+  end
+end

data/lib/ahoy/engine.rb

@@ -1,10 +1,8 @@
 module Ahoy
   class Engine < ::Rails::Engine
-    initializer "ahoy.middleware", after: "sprockets.environment" do |app|
-      if Ahoy.throttle
-        require "ahoy/throttle"
-        app.middleware.use Ahoy::Throttle
-      end
+    initializer "ahoy", after: "sprockets.environment" do |app|
+      # allow Devise to be loaded after Ahoy
+      require "ahoy/warden" if defined?(Warden)
 
       next unless Ahoy.quiet
 
@@ -14,8 +12,8 @@ module Ahoy
       # Just create an alias for call in middleware
       Rails::Rack::Logger.class_eval do
         def call_with_quiet_ahoy(env)
-          if env["PATH_INFO"].start_with?(AHOY_PREFIX) && logger.respond_to?(:silence_logger)
-            logger.silence_logger do
+          if env["PATH_INFO"].start_with?(AHOY_PREFIX) && logger.respond_to?(:silence)
+            logger.silence do
               call_without_quiet_ahoy(env)
             end
           else

data/lib/ahoy/model.rb

@@ -1,37 +1,15 @@
 module Ahoy
   module Model
-    def visitable(name = nil, options = {})
-      if name.is_a?(Hash)
-        options = name
-        name = nil
-      end
-      name ||= :visit
+    def visitable(name = :visit, **options)
       class_eval do
-        belongs_to name, options
-        before_create :set_visit
+        belongs_to(name, optional: true, class_name: "Ahoy::Visit", **options)
+        before_create :set_ahoy_visit
       end
       class_eval %{
-        def set_visit
+        def set_ahoy_visit
           self.#{name} ||= RequestStore.store[:ahoy].try(:visit)
         end
       }
     end
-
-    # deprecated
-
-    def ahoy_visit
-      class_eval do
-        warn "[DEPRECATION] ahoy_visit is deprecated"
-
-        belongs_to :user, polymorphic: true
-
-        def landing_params
-          @landing_params ||= begin
-            warn "[DEPRECATION] landing_params is deprecated"
-            Deckhands::UtmParameterDeckhand.new(landing_page).landing_params
-          end
-        end
-      end
-    end
   end
 end

data/lib/ahoy/{properties.rb → query_methods.rb}

@@ -1,13 +1,23 @@
 module Ahoy
-  module Properties
+  module QueryMethods
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def where_properties(properties)
+      def where_event(name, properties = {})
+        where(name: name).where_props(properties)
+      end
+
+      def where_props(properties)
         relation = self
-        column_type = columns_hash["properties"].type
-        adapter_name = connection.adapter_name.downcase
+        if respond_to?(:columns_hash)
+          column_type = columns_hash["properties"].type
+          adapter_name = connection.adapter_name.downcase
+        else
+          adapter_name = "mongoid"
+        end
         case adapter_name
+        when "mongoid"
+          relation = where(Hash[properties.map { |k, v| ["properties.#{k}", v] }])
         when /mysql/
           if column_type == :json
             properties.each do |k, v|
@@ -55,6 +65,10 @@ module Ahoy
         end
         relation
       end
+      alias_method :where_properties, :where_props
     end
   end
 end
+
+# backward compatibility
+Ahoy::Properties = Ahoy::QueryMethods

data/lib/ahoy/tracker.rb

@@ -2,45 +2,56 @@ module Ahoy
   class Tracker
     attr_reader :request, :controller
 
-    def initialize(options = {})
+    def initialize(**options)
       @store = Ahoy::Store.new(options.merge(ahoy: self))
       @controller = options[:controller]
       @request = options[:request] || @controller.try(:request)
+      @visit_token = options[:visit_token]
       @options = options
     end
 
+    # can't use keyword arguments here
     def track(name, properties = {}, options = {})
       if exclude?
         debug "Event excluded"
       elsif missing_params?
         debug "Missing required parameters"
       else
-        options = options.dup
-
-        options[:time] = trusted_time(options[:time])
-        options[:id] = ensure_uuid(options[:id] || generate_id)
-
-        @store.track_event(name, properties, options)
+        data = {
+          visit_token: visit_token,
+          user_id: user.try(:id),
+          name: name.to_s,
+          properties: properties,
+          time: trusted_time(options[:time]),
+          event_id: options[:id] || generate_id
+        }.select { |_, v| v }
+
+        @store.track_event(data)
       end
       true
     rescue => e
       report_exception(e)
     end
 
-    def track_visit(options = {})
+    def track_visit(defer: false)
       if exclude?
         debug "Visit excluded"
       elsif missing_params?
         debug "Missing required parameters"
       else
-        if options[:defer]
+        if defer
           set_cookie("ahoy_track", true, nil, false)
         else
-          options = options.dup
+          data = {
+            visit_token: visit_token,
+            visitor_token: visitor_token,
+            user_id: user.try(:id),
+            started_at: trusted_time,
+          }.merge(visit_properties).select { |_, v| v }
 
-          options[:started_at] ||= Time.zone.now
+          @store.track_visit(data)
 
-          @store.track_visit(options)
+          Ahoy::GeocodeV2Job.perform_later(visit_token, data[:ip]) if Ahoy.geocode
         end
       end
       true
@@ -48,11 +59,28 @@ module Ahoy
       report_exception(e)
     end
 
+    def geocode(data)
+      if exclude?
+        debug "Geocode excluded"
+      else
+        @store.geocode(data.select { |_, v| v })
+        true
+      end
+    rescue => e
+      report_exception(e)
+    end
+
     def authenticate(user)
       if exclude?
         debug "Authentication excluded"
       else
-        @store.authenticate(user)
+        @store.user = user
+
+        data = {
+          visit_token: visit_token,
+          user_id: user.try(:id)
+        }
+        @store.authenticate(data)
       end
       true
     rescue => e
@@ -63,14 +91,6 @@ module Ahoy
       @visit ||= @store.visit
     end
 
-    def visit_id
-      @visit_id ||= ensure_uuid(visit_token_helper)
-    end
-
-    def visitor_id
-      @visitor_id ||= ensure_uuid(visitor_token_helper)
-    end
-
     def new_visit?
       !existing_visit_token
     end
@@ -80,12 +100,12 @@ module Ahoy
     end
 
     def set_visit_cookie
-      set_cookie("ahoy_visit", visit_id, Ahoy.visit_duration)
+      set_cookie("ahoy_visit", visit_token, Ahoy.visit_duration)
     end
 
     def set_visitor_cookie
       if new_visitor?
-        set_cookie("ahoy_visitor", visitor_id, Ahoy.visitor_duration)
+        set_cookie("ahoy_visitor", visitor_token, Ahoy.visitor_duration)
       end
     end
 
@@ -95,16 +115,29 @@ module Ahoy
 
     # TODO better name
     def visit_properties
-      @visit_properties ||= Ahoy::VisitProperties.new(request, api: api?)
+      @visit_properties ||= Ahoy::VisitProperties.new(request, api: api?).generate
     end
 
     def visit_token
       @visit_token ||= ensure_token(visit_token_helper)
     end
+    alias_method :visit_id, :visit_token
 
     def visitor_token
       @visitor_token ||= ensure_token(visitor_token_helper)
     end
+    alias_method :visitor_id, :visitor_token
+
+    def reset
+      reset_visit
+      request.cookie_jar.delete("ahoy_visitor")
+    end
+
+    def reset_visit
+      request.cookie_jar.delete("ahoy_visit")
+      request.cookie_jar.delete("ahoy_events")
+      request.cookie_jar.delete("ahoy_track")
+    end
 
     protected
 
@@ -125,12 +158,12 @@ module Ahoy
         value: value
       }
       cookie[:expires] = duration.from_now if duration
-      domain = Ahoy.cookie_domain || Ahoy.domain
+      domain = Ahoy.cookie_domain
       cookie[:domain] = domain if domain && use_domain
       request.cookie_jar[name] = cookie
     end
 
-    def trusted_time(time)
+    def trusted_time(time = nil)
       if !time || (api? && !(1.minute.ago..Time.now).cover?(time))
         Time.zone.now
       else
@@ -142,15 +175,8 @@ module Ahoy
       @store.exclude?
     end
 
-    # odd pattern for backwards compatibility
-    # TODO remove this method in next major release
     def report_exception(e)
-      Safely.safely do
-        @store.report_exception(e)
-        if Rails.env.development? || Rails.env.test?
-          raise e
-        end
-      end
+      Safely.report_exception(e)
     end
 
     def generate_id
@@ -215,10 +241,6 @@ module Ahoy
       @visitor_param ||= request && request.params["visitor_token"]
     end
 
-    def ensure_uuid(id)
-      Ahoy.ensure_uuid(id) if id
-    end
-
     def ensure_token(token)
       token.to_s.gsub(/[^a-z0-9\-]/i, "").first(64) if token
     end