ahoy_matey 1.5.5 → 4.2.1

data/app/controllers/ahoy/base_controller.rb

@@ -1,34 +1,42 @@
 module Ahoy
   class BaseController < ApplicationController
-    # skip all filters except for authlogic
-    filters = _process_action_callbacks.map(&:filter) - [:load_authlogic]
-    if Rails::VERSION::MAJOR >= 5
-      skip_before_action(*filters, raise: false)
-      skip_after_action(*filters, raise: false)
-      skip_around_action(*filters, raise: false)
-      before_action :verify_request_size
-    elsif respond_to?(:skip_action_callback)
-      skip_action_callback *filters
-      before_action :verify_request_size
-    else
-      skip_filter *filters
-      before_filter :verify_request_size
-    end
+    filters = _process_action_callbacks.map(&:filter) - Ahoy.preserve_callbacks
+    skip_before_action(*filters, raise: false)
+    skip_after_action(*filters, raise: false)
+    skip_around_action(*filters, raise: false)
 
     if respond_to?(:protect_from_forgery)
       protect_from_forgery with: :null_session, if: -> { Ahoy.protect_from_forgery }
     end
 
+    before_action :verify_request_size
+    before_action :check_params
+    before_action :renew_cookies
+
     protected
 
     def ahoy
       @ahoy ||= Ahoy::Tracker.new(controller: self, api: true)
     end
 
+    def check_params
+      if ahoy.send(:missing_params?)
+        logger.info "[ahoy] Missing required parameters"
+        render plain: "Missing required parameters\n", status: :bad_request
+      end
+    end
+
+    # set proper ttl if cookie generated from JavaScript
+    # approach is not perfect, as user must reload the page
+    # for new cookie settings to take effect
+    def renew_cookies
+      set_ahoy_cookies if params[:js] && !Ahoy.api_only
+    end
+
     def verify_request_size
       if request.content_length > Ahoy.max_content_length
         logger.info "[ahoy] Payload too large"
-        render text: "Payload too large\n", status: 413
+        render plain: "Payload too large\n", status: :payload_too_large
       end
     end
   end

data/app/controllers/ahoy/events_controller.rb

@@ -3,13 +3,19 @@ module Ahoy
     def create
       events =
         if params[:name]
-          # legacy API
+          # legacy API and AMP
           [request.params]
         elsif params[:events]
           request.params[:events]
         else
+          data =
+            if params[:events_json]
+              request.params[:events_json]
+            else
+              request.body.read
+            end
           begin
-            ActiveSupport::JSON.decode(request.body.read)
+            ActiveSupport::JSON.decode(data)
           rescue ActiveSupport::JSON.parse_error
             # do nothing
             []

data/app/controllers/ahoy/visits_controller.rb

@@ -2,7 +2,14 @@ module Ahoy
   class VisitsController < BaseController
     def create
       ahoy.track_visit
-      render json: {visit_id: ahoy.visit_id, visitor_id: ahoy.visitor_id}
+
+      render json: {
+        visit_token: ahoy.visit_token,
+        visitor_token: ahoy.visitor_token,
+        # legacy
+        visit_id: ahoy.visit_token,
+        visitor_id: ahoy.visitor_token
+      }
     end
   end
 end

data/app/jobs/ahoy/geocode_job.rb

@@ -0,0 +1,11 @@
+# for smooth update from Ahoy 1 -> 2
+# TODO remove in 5.0
+module Ahoy
+  class GeocodeJob < ActiveJob::Base
+    queue_as { Ahoy.job_queue }
+
+    def perform(visit)
+      Ahoy::GeocodeV2Job.perform_now(visit.visit_token, visit.ip)
+    end
+  end
+end

data/app/jobs/ahoy/geocode_v2_job.rb

@@ -0,0 +1,31 @@
+module Ahoy
+  class GeocodeV2Job < ActiveJob::Base
+    queue_as { Ahoy.job_queue }
+
+    def perform(visit_token, ip)
+      location =
+        begin
+          Geocoder.search(ip).first
+        rescue NameError
+          raise "Add the geocoder gem to your Gemfile to use geocoding"
+        rescue => e
+          Ahoy.log "Geocode error: #{e.class.name}: #{e.message}"
+          nil
+        end
+
+      if location && location.country.present?
+        data = {
+          country: location.country,
+          country_code: location.try(:country_code).presence,
+          region: location.try(:state).presence,
+          city: location.try(:city).presence,
+          postal_code: location.try(:postal_code).presence,
+          latitude: location.try(:latitude).presence,
+          longitude: location.try(:longitude).presence
+        }
+
+        Ahoy::Tracker.new(visit_token: visit_token).geocode(data)
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -1,5 +1,5 @@
 Rails.application.routes.draw do
-  mount Ahoy::Engine => "/ahoy" if Ahoy.mount
+  mount Ahoy::Engine => "/ahoy" if Ahoy.api
 end
 
 Ahoy::Engine.routes.draw do

data/lib/ahoy/base_store.rb

@@ -0,0 +1,101 @@
+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)
+          if Ahoy.user_method.arity == 1
+            Ahoy.user_method.call(controller)
+          else
+            Ahoy.user_method.call(controller, request)
+          end
+        else
+          controller.send(Ahoy.user_method) if controller.respond_to?(Ahoy.user_method, true)
+        end
+      end
+    end
+
+    def exclude?
+      (!Ahoy.track_bots && bot?) || exclude_by_method?
+    end
+
+    def generate_id
+      Ahoy.token_generator.call
+    end
+
+    def visit_or_create
+      visit
+    end
+
+    protected
+
+    def bot?
+      unless defined?(@bot)
+        @bot = begin
+          if request
+            if Ahoy.user_agent_parser == :device_detector
+              detector = DeviceDetector.new(request.user_agent)
+              if Ahoy.bot_detection_version == 2
+                detector.bot? || (detector.device_type.nil? && detector.os_name.nil?)
+              else
+                detector.bot?
+              end
+            else
+              # no need to throw friendly error if browser isn't defined
+              # since will error in visit_properties
+              Browser.new(request.user_agent).bot?
+            end
+          else
+            false
+          end
+        end
+      end
+
+      @bot
+    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

@@ -1,5 +1,3 @@
-require "request_store"
-
 module Ahoy
   module Controller
     def self.included(base)
@@ -7,15 +5,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.around_action :set_ahoy_request_store
     end
 
     def ahoy
@@ -27,18 +19,33 @@ module Ahoy
     end
 
     def set_ahoy_cookies
-      ahoy.set_visitor_cookie
-      ahoy.set_visit_cookie
+      if Ahoy.cookies
+        ahoy.set_visitor_cookie
+        ahoy.set_visit_cookie
+      else
+        # delete cookies if exist
+        ahoy.reset
+      end
     end
 
     def track_ahoy_visit
-      if ahoy.new_visit?
-        ahoy.track_visit(defer: !Ahoy.track_visits_immediately)
+      defer = Ahoy.server_side_visits != true
+
+      if defer && !Ahoy.cookies
+        # avoid calling new_visit?, which triggers a database call
+      elsif ahoy.new_visit?
+        ahoy.track_visit(defer: defer)
       end
     end
 
     def set_ahoy_request_store
-      RequestStore.store[:ahoy] ||= ahoy
+      previous_value = Ahoy.instance
+      begin
+        Ahoy.instance = ahoy
+        yield
+      ensure
+        Ahoy.instance = previous_value
+      end
     end
   end
 end

data/lib/ahoy/database_store.rb

@@ -0,0 +1,94 @@
+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)
+
+      # so next call to visit will try to fetch from DB
+      if defined?(@visit)
+        remove_instance_variable(:@visit)
+      end
+    end
+
+    def track_event(data)
+      visit = visit_or_create(started_at: data[:time])
+      if visit
+        event = event_model.new(slice_data(event_model, data))
+        event.visit = visit
+        event.time = visit.started_at if event.time < visit.started_at
+        begin
+          event.save!
+        rescue => e
+          raise e unless unique_exception?(e)
+        end
+      else
+        Ahoy.log "Event excluded since visit not created: #{data[:visit_token]}"
+      end
+    end
+
+    def geocode(data)
+      visit_token = data.delete(:visit_token)
+      data = slice_data(visit_model, data)
+      if defined?(Mongoid::Document) && visit_model < Mongoid::Document
+        # upsert since visit might not be found due to eventual consistency
+        visit_model.where(visit_token: visit_token).find_one_and_update({"$set": data}, {upsert: true})
+      elsif visit
+        visit.update!(data)
+      else
+        Ahoy.log "Visit for geocode not found: #{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
+      unless defined?(@visit)
+        if defined?(Mongoid::Document) && visit_model < Mongoid::Document
+          # find_by raises error by default when not found
+          @visit = visit_model.where(visit_token: ahoy.visit_token).first if ahoy.visit_token
+        else
+          @visit = visit_model.find_by(visit_token: ahoy.visit_token) if ahoy.visit_token
+        end
+      end
+      @visit
+    end
+
+    # if we don't have a visit, let's try to create one first
+    def visit_or_create(started_at: nil)
+      ahoy.track_visit(started_at: started_at) if !visit && Ahoy.server_side_visits
+      visit
+    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.nil? }
+    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,10 @@
 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
+      Ahoy.logger ||= Rails.logger
+
+      # allow Devise to be loaded after Ahoy
+      require "ahoy/warden" if defined?(Warden)
 
       next unless Ahoy.quiet
 
@@ -14,8 +14,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
@@ -26,5 +26,12 @@ module Ahoy
         alias_method :call, :call_with_quiet_ahoy
       end
     end
+
+    # for importmap
+    initializer "ahoy.importmap" do |app|
+      if defined?(Importmap)
+        app.config.assets.precompile << "ahoy.js"
+      end
+    end
   end
 end

data/lib/ahoy/helper.rb

@@ -0,0 +1,40 @@
+module Ahoy
+  module Helper
+    def amp_event(name, properties = {})
+      url = Ahoy::Engine.routes.url_helpers.events_url(
+        url_options.slice(:host, :port, :protocol).merge(
+          name: name,
+          properties: properties,
+          screen_width: "SCREEN_WIDTH",
+          screen_height: "SCREEN_HEIGHT",
+          platform: "Web",
+          landing_page: "AMPDOC_URL",
+          referrer: "DOCUMENT_REFERRER",
+          random: "RANDOM"
+        )
+      )
+      url = "#{url}&visit_token=${clientId(ahoy_visit)}&visitor_token=${clientId(ahoy_visitor)}"
+
+      content_tag "amp-analytics" do
+        content_tag "script", type: "application/json" do
+          json_escape({
+            requests: {
+              pageview: url
+            },
+            triggers: {
+              trackPageview: {
+                on: "visible",
+                request: "pageview"
+              }
+            },
+            transport: {
+              beacon: true,
+              xhrpost: true,
+              image: false
+            }
+          }.to_json).html_safe
+        end
+      end
+    end
+  end
+end

data/lib/ahoy/model.rb

@@ -1,37 +1,15 @@
 module Ahoy
   module Model
-    def visitable(name = nil, options = {})
-      if name.is_a?(Hash)
-        name = nil
-        options = name
-      end
-      name ||= :visit
+    def visitable(name = :visit, **options)
       class_eval do
-        belongs_to name, options
-        before_create :set_visit
+        belongs_to(name, class_name: "Ahoy::Visit", optional: true, **options)
+        before_create :set_ahoy_visit
       end
       class_eval %{
-        def set_visit
-          self.#{name} ||= RequestStore.store[:ahoy].try(:visit)
+        def set_ahoy_visit
+          self.#{name} ||= Ahoy.instance.try(:visit_or_create)
         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/query_methods.rb

@@ -0,0 +1,88 @@
+module Ahoy
+  module QueryMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def where_event(name, properties = {})
+        where(name: name).where_props(properties)
+      end
+
+      def where_props(properties)
+        return all if properties.empty?
+
+        adapter_name = respond_to?(:connection) ? connection.adapter_name.downcase : "mongoid"
+        case adapter_name
+        when "mongoid"
+          where(properties.to_h { |k, v| ["properties.#{k}", v] })
+        when /mysql/
+          where("JSON_CONTAINS(properties, ?, '$') = 1", properties.to_json)
+        when /postgres|postgis/
+          case columns_hash["properties"].type
+          when :hstore
+            properties.inject(all) do |relation, (k, v)|
+              if v.nil?
+                relation.where("properties -> ? IS NULL", k.to_s)
+              else
+                relation.where("properties -> ? = ?", k.to_s, v.to_s)
+              end
+            end
+          when :jsonb
+            where("properties @> ?", properties.to_json)
+          else
+            where("properties::jsonb @> ?", properties.to_json)
+          end
+        when /sqlite/
+          properties.inject(all) do |relation, (k, v)|
+            if v.nil?
+              relation.where("JSON_EXTRACT(properties, ?) IS NULL", "$.#{k}")
+            else
+              relation.where("JSON_EXTRACT(properties, ?) = ?", "$.#{k}", v.as_json)
+            end
+          end
+        else
+          raise "Adapter not supported: #{adapter_name}"
+        end
+      end
+      alias_method :where_properties, :where_props
+
+      def group_prop(*props)
+        # like with group
+        props.flatten!
+
+        relation = all
+        adapter_name = respond_to?(:connection) ? connection.adapter_name.downcase : "mongoid"
+        case adapter_name
+        when "mongoid"
+          raise "Adapter not supported: #{adapter_name}"
+        when /mysql/
+          props.each do |prop|
+            quoted_prop = connection.quote("$.#{prop}")
+            relation = relation.group("JSON_UNQUOTE(JSON_EXTRACT(properties, #{quoted_prop}))")
+          end
+        when /postgres|postgis/
+          # convert to jsonb to fix
+          # could not identify an equality operator for type json
+          # and for text columns
+          column_type = columns_hash["properties"].type
+          cast = [:jsonb, :hstore].include?(column_type) ? "" : "::jsonb"
+
+          props.each do |prop|
+            quoted_prop = connection.quote(prop)
+            relation = relation.group("properties#{cast} -> #{quoted_prop}")
+          end
+        when /sqlite/
+          props.each do |prop|
+            quoted_prop = connection.quote("$.#{prop}")
+            relation = relation.group("JSON_EXTRACT(properties, #{quoted_prop})")
+          end
+        else
+          raise "Adapter not supported: #{adapter_name}"
+        end
+        relation
+      end
+    end
+  end
+end
+
+# backward compatibility
+Ahoy::Properties = Ahoy::QueryMethods