ahoy_matey 1.5.3 → 3.0.1

data/lib/ahoy/database_store.rb

@@ -0,0 +1,89 @@
+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)
+        @visit = visit_model.where(visit_token: ahoy.visit_token).first if ahoy.visit_token
+      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

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} ||= Thread.current[:ahoy].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/{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|
@@ -17,15 +27,17 @@ module Ahoy
                 v = "true"
               end
 
-              relation = relation.where("JSON_UNQUOTE(properties -> ?) = ?", "$.#{k.to_s}", v.as_json)
+              relation = relation.where("JSON_UNQUOTE(properties -> ?) = ?", "$.#{k}", v.as_json)
             end
           else
             properties.each do |k, v|
-              relation = relation.where("properties REGEXP ?", "[{,]#{{k.to_s => v}.to_json.sub(/\A\{/, "").sub(/\}\z/, "")}[,}]")
+              relation = relation.where("properties REGEXP ?", "[{,]#{{k.to_s => v}.to_json.sub(/\A\{/, "").sub(/\}\z/, "").gsub("+", "\\\\+")}[,}]")
             end
           end
-        when /postgres/
-          if column_type == :jsonb || column_type == :json
+        when /postgres|postgis/
+          if column_type == :jsonb
+            relation = relation.where("properties @> ?", properties.to_json)
+          elsif column_type == :json
             properties.each do |k, v|
               relation =
                 if v.nil?
@@ -45,7 +57,7 @@ module Ahoy
             end
           else
             properties.each do |k, v|
-              relation = relation.where("properties SIMILAR TO ?", "%[{,]#{{k.to_s => v}.to_json.sub(/\A\{/, "").sub(/\}\z/, "")}[,}]%")
+              relation = relation.where("properties SIMILAR TO ?", "%[{,]#{{k.to_s => v}.to_json.sub(/\A\{/, "").sub(/\}\z/, "").gsub("+", "\\\\+")}[,}]%")
             end
           end
         else
@@ -53,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

@@ -1,46 +1,64 @@
+require "active_support/core_ext/digest/uuid"
+
 module Ahoy
   class Tracker
+    UUID_NAMESPACE = "a82ae811-5011-45ab-a728-569df7499c5f"
+
     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]
+      @user = options[:user]
       @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, started_at: nil)
       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
+          delete_cookie("ahoy_track")
 
-          options[:started_at] ||= Time.zone.now
+          data = {
+            visit_token: visit_token,
+            visitor_token: visitor_token,
+            user_id: user.try(:id),
+            started_at: trusted_time(started_at),
+          }.merge(visit_properties).select { |_, v| v }
 
-          @store.track_visit(options)
+          @store.track_visit(data)
+
+          Ahoy::GeocodeV2Job.perform_later(visit_token, data[:ip]) if Ahoy.geocode && data[:ip]
         end
       end
       true
@@ -48,11 +66,32 @@ module Ahoy
       report_exception(e)
     end
 
+    def geocode(data)
+      if exclude?
+        debug "Geocode excluded"
+      else
+        data = {
+          visit_token: visit_token
+          }.merge(data).select { |_, v| v }
+
+        @store.geocode(data)
+        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,16 +102,12 @@ 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)
+    def visit_or_create
+      @visit ||= @store.visit_or_create
     end
 
     def new_visit?
-      !existing_visit_token
+      Ahoy.cookies ? !existing_visit_token : visit.nil?
     end
 
     def new_visitor?
@@ -80,12 +115,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
 
@@ -93,18 +128,30 @@ module Ahoy
       @user ||= @store.user
     end
 
-    # TODO better name
     def visit_properties
-      @visit_properties ||= Ahoy::VisitProperties.new(request, api: api?)
+      @visit_properties ||= request ? 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
+      delete_cookie("ahoy_visitor")
+    end
+
+    def reset_visit
+      delete_cookie("ahoy_visit")
+      delete_cookie("ahoy_events")
+      delete_cookie("ahoy_track")
+    end
 
     protected
 
@@ -113,7 +160,7 @@ module Ahoy
     end
 
     def missing_params?
-      if api? && Ahoy.protect_from_forgery
+      if Ahoy.cookies && api? && Ahoy.protect_from_forgery
         !(existing_visit_token && existing_visitor_token)
       else
         false
@@ -121,18 +168,25 @@ module Ahoy
     end
 
     def set_cookie(name, value, duration = nil, use_domain = true)
+      # safety net
+      return unless Ahoy.cookies && request
+
       cookie = {
         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 delete_cookie(name)
+      request.cookie_jar.delete(name) if request && request.cookie_jar[name]
+    end
+
+    def trusted_time(time = nil)
       if !time || (api? && !(1.minute.ago..Time.now).cover?(time))
-        Time.zone.now
+        Time.current
       else
         time
       end
@@ -142,14 +196,12 @@ 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
+      if defined?(ActionDispatch::RemoteIp::IpSpoofAttackError) && e.is_a?(ActionDispatch::RemoteIp::IpSpoofAttackError)
+        debug "Tracking excluded due to IP spoofing"
+      else
+        raise e if !defined?(Rails) || Rails.env.development? || Rails.env.test?
+        Safely.report_exception(e)
       end
     end
 
@@ -160,6 +212,7 @@ module Ahoy
     def visit_token_helper
       @visit_token_helper ||= begin
         token = existing_visit_token
+        token ||= visit_anonymity_set unless Ahoy.cookies
         token ||= generate_id unless Ahoy.api_only
         token
       end
@@ -168,6 +221,7 @@ module Ahoy
     def visitor_token_helper
       @visitor_token_helper ||= begin
         token = existing_visitor_token
+        token ||= visitor_anonymity_set unless Ahoy.cookies
         token ||= generate_id unless Ahoy.api_only
         token
       end
@@ -176,7 +230,7 @@ module Ahoy
     def existing_visit_token
       @existing_visit_token ||= begin
         token = visit_header
-        token ||= visit_cookie unless api? && Ahoy.protect_from_forgery
+        token ||= visit_cookie if Ahoy.cookies && !(api? && Ahoy.protect_from_forgery)
         token ||= visit_param if api?
         token
       end
@@ -185,12 +239,20 @@ module Ahoy
     def existing_visitor_token
       @existing_visitor_token ||= begin
         token = visitor_header
-        token ||= visitor_cookie unless api? && Ahoy.protect_from_forgery
+        token ||= visitor_cookie if Ahoy.cookies && !(api? && Ahoy.protect_from_forgery)
         token ||= visitor_param if api?
         token
       end
     end
 
+    def visit_anonymity_set
+      @visit_anonymity_set ||= Digest::UUID.uuid_v5(UUID_NAMESPACE, ["visit", Ahoy.mask_ip(request.remote_ip), request.user_agent].join("/"))
+    end
+
+    def visitor_anonymity_set
+      @visitor_anonymity_set ||= Digest::UUID.uuid_v5(UUID_NAMESPACE, ["visitor", Ahoy.mask_ip(request.remote_ip), request.user_agent].join("/"))
+    end
+
     def visit_cookie
       @visit_cookie ||= request && request.cookies["ahoy_visit"]
     end
@@ -215,16 +277,13 @@ 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 = Ahoy::Utils.ensure_utf8(token)
       token.to_s.gsub(/[^a-z0-9\-]/i, "").first(64) if token
     end
 
     def debug(message)
-      Rails.logger.debug { "[ahoy] #{message}" }
+      Ahoy.log message
     end
   end
 end