ahoy_matey 1.6.1 → 2.0.0

data/lib/ahoy/deckhands/traffic_source_deckhand.rb

@@ -1,22 +0,0 @@
-module Ahoy
-  module Deckhands
-    class TrafficSourceDeckhand
-      def initialize(referrer)
-        @referrer = referrer
-      end
-
-      def referring_domain
-        @referring_domain ||= Addressable::URI.parse(@referrer).host.first(255) rescue nil
-      end
-
-      def search_keyword
-        @search_keyword ||= (self.class.referrer_parser.parse(@referrer)[:term][0..255] rescue nil).presence
-      end
-
-      # performance hack for referer-parser
-      def self.referrer_parser
-        @referrer_parser ||= RefererParser::Parser.new
-      end
-    end
-  end
-end

data/lib/ahoy/deckhands/utm_parameter_deckhand.rb

@@ -1,23 +0,0 @@
-module Ahoy
-  module Deckhands
-    class UtmParameterDeckhand
-      def initialize(landing_page, params = nil)
-        @landing_page = landing_page
-        @params = params || {}
-      end
-
-      def landing_params
-        @landing_params ||= begin
-          landing_uri = Addressable::URI.parse(@landing_page) rescue nil
-          (landing_uri && landing_uri.query_values) || {}
-        end
-      end
-
-      %w(utm_source utm_medium utm_term utm_content utm_campaign).each do |name|
-        define_method name do
-          @params[name] || landing_params[name]
-        end
-      end
-    end
-  end
-end

data/lib/ahoy/geocode_job.rb

@@ -1,13 +0,0 @@
-module Ahoy
-  class GeocodeJob < ActiveJob::Base
-    queue_as :ahoy
-
-    def perform(visit)
-      deckhand = Deckhands::LocationDeckhand.new(visit.ip)
-      Ahoy::VisitProperties::LOCATION_KEYS.each do |key|
-        visit.send(:"#{key}=", deckhand.send(key)) if visit.respond_to?(:"#{key}=")
-      end
-      visit.save!
-    end
-  end
-end

data/lib/ahoy/logger_silencer.rb

@@ -1,75 +0,0 @@
-# from https://github.com/rails/activerecord-session_store/blob/master/lib/active_record/session_store/extension/logger_silencer.rb
-require "thread"
-require "active_support/core_ext/class/attribute_accessors"
-require "active_support/core_ext/module/aliasing"
-require "active_support/core_ext/module/attribute_accessors"
-require "active_support/concern"
-
-module Ahoy
-  module LoggerSilencer
-    extend ActiveSupport::Concern
-
-    included do
-      cattr_accessor :silencer
-      self.silencer = true
-      alias_method :level_without_threadsafety, :level
-      alias_method :level, :level_with_threadsafety
-      alias_method :add_without_threadsafety, :add
-      alias_method :add, :add_with_threadsafety
-    end
-
-    def thread_level
-      Thread.current[thread_hash_level_key]
-    end
-
-    def thread_level=(level)
-      Thread.current[thread_hash_level_key] = level
-    end
-
-    def level_with_threadsafety
-      thread_level || level_without_threadsafety
-    end
-
-    def add_with_threadsafety(severity, message = nil, progname = nil, &block)
-      if (defined?(@logdev) && @logdev.nil?) || (severity || UNKNOWN) < level
-        true
-      else
-        add_without_threadsafety(severity, message, progname, &block)
-      end
-    end
-
-    # Silences the logger for the duration of the block.
-    def silence_logger(temporary_level = Logger::ERROR)
-      if silencer
-        begin
-          self.thread_level = temporary_level
-          yield self
-        ensure
-          self.thread_level = nil
-        end
-      else
-        yield self
-      end
-    end
-
-    for severity in Logger::Severity.constants
-      class_eval <<-EOT, __FILE__, __LINE__ + 1
-        def #{severity.downcase}?                # def debug?
-          Logger::#{severity} >= level           #   DEBUG >= level
-        end                                      # end
-      EOT
-    end
-
-    private
-
-    def thread_hash_level_key
-      @thread_hash_level_key ||= :"ThreadSafeLogger##{object_id}@level"
-    end
-  end
-end
-
-class NilLogger
-  def self.silence_logger
-    yield
-  end
-end

data/lib/ahoy/stores/active_record_store.rb

@@ -1,61 +0,0 @@
-module Ahoy
-  module Stores
-    class ActiveRecordStore < BaseStore
-      def track_visit(options, &block)
-        @visit =
-          visit_model.new do |v|
-            v.id = ahoy.visit_id
-            v.visitor_id = ahoy.visitor_id
-            v.user = user if v.respond_to?(:user=)
-            v.started_at = options[:started_at]
-          end
-
-        set_visit_properties(visit)
-
-        yield(visit) if block_given?
-
-        begin
-          visit.save!
-          geocode(visit)
-        rescue *unique_exception_classes
-          # reset to nil so subsequent calls to track_event will load visit from DB
-          @visit = nil
-        end
-      end
-
-      def track_event(name, properties, options, &block)
-        event =
-          event_model.new do |e|
-            e.id = options[:id]
-            e.visit_id = ahoy.visit_id
-            e.user = user if e.respond_to?(:user=)
-            e.name = name
-            e.properties = properties
-            e.time = options[:time]
-          end
-
-        yield(event) if block_given?
-
-        begin
-          event.save!
-        rescue *unique_exception_classes
-          # do nothing
-        end
-      end
-
-      def visit
-        @visit ||= visit_model.where(id: ahoy.visit_id).first if ahoy.visit_id
-      end
-
-      protected
-
-      def visit_model
-        ::Visit
-      end
-
-      def event_model
-        ::Ahoy::Event
-      end
-    end
-  end
-end

data/lib/ahoy/stores/active_record_token_store.rb

@@ -1,114 +0,0 @@
-module Ahoy
-  module Stores
-    class ActiveRecordTokenStore < BaseStore
-      def track_visit(options, &block)
-        @visit =
-          visit_model.new do |v|
-            v.visit_token = ahoy.visit_token
-            v.visitor_token = ahoy.visitor_token
-            v.user = user if v.respond_to?(:user=)
-            v.started_at = options[:started_at] if v.respond_to?(:started_at)
-            v.created_at = options[:started_at] if v.respond_to?(:created_at)
-          end
-
-        set_visit_properties(visit)
-
-        yield(visit) if block_given?
-
-        begin
-          visit.save!
-          geocode(visit)
-        rescue *unique_exception_classes
-          # reset to nil so subsequent calls to track_event will load visit from DB
-          @visit = nil
-        end
-      end
-
-      def track_event(name, properties, options, &block)
-        if self.class.uses_deprecated_subscribers?
-          options[:controller] ||= controller
-          options[:user] ||= user
-          options[:visit] ||= visit
-          options[:visit_token] ||= ahoy.visit_token
-          options[:visitor_token] ||= ahoy.visitor_token
-
-          subscribers = Ahoy.subscribers
-          if subscribers.any?
-            subscribers.each do |subscriber|
-              subscriber.track(name, properties, options.dup)
-            end
-          else
-            $stderr.puts "No subscribers"
-          end
-        else
-          event =
-            event_model.new do |e|
-              e.visit_id = visit.try(:id)
-              e.user = user if e.respond_to?(:user=)
-              e.name = name
-              e.properties = properties
-              e.time = options[:time]
-            end
-
-          yield(event) if block_given?
-
-          event.save!
-        end
-      end
-
-      def visit
-        @visit ||= (visit_model.where(visit_token: ahoy.visit_token).first if ahoy.visit_token)
-      end
-
-      def exclude?
-        (!Ahoy.track_bots && bot?) ||
-          (
-            if Ahoy.exclude_method
-              warn "[DEPRECATION] Ahoy.exclude_method is deprecated - use exclude? instead"
-              if Ahoy.exclude_method.arity == 1
-                Ahoy.exclude_method.call(controller)
-              else
-                Ahoy.exclude_method.call(controller, request)
-              end
-            else
-              false
-            end
-          )
-      end
-
-      def user
-        @user ||= begin
-          user_method = Ahoy.user_method
-          if user_method.respond_to?(:call)
-            user_method.call(controller)
-          elsif user_method
-            controller.send(user_method)
-          else
-            super
-          end
-        end
-      end
-
-      class << self
-        def uses_deprecated_subscribers
-          warn "[DEPRECATION] Ahoy subscribers are deprecated"
-          @uses_deprecated_subscribers = true
-        end
-
-        def uses_deprecated_subscribers?
-          @uses_deprecated_subscribers || false
-        end
-      end
-
-      protected
-
-      def visit_model
-        Ahoy.visit_model || ::Visit
-      end
-
-      def event_model
-        ::Ahoy::Event
-      end
-    end
-  end
-end

data/lib/ahoy/stores/base_store.rb

@@ -1,88 +0,0 @@
-module Ahoy
-  module Stores
-    class BaseStore
-      def initialize(options)
-        @options = options
-      end
-
-      def track_visit(options)
-      end
-
-      def track_event(name, properties, options)
-      end
-
-      def visit
-      end
-
-      def authenticate(user)
-        @user = user
-        if visit && visit.respond_to?(:user) && !visit.user
-          begin
-            visit.user = user
-            visit.save!
-          rescue ActiveRecord::AssociationTypeMismatch
-            # do nothing
-          end
-        end
-      end
-
-      def report_exception(e)
-        raise e
-      end
-
-      def user
-        @user ||= (controller.respond_to?(:current_user) && controller.current_user) || (controller.respond_to?(:current_resource_owner, true) && controller.send(:current_resource_owner)) || nil
-      end
-
-      def exclude?
-        bot?
-      end
-
-      def generate_id
-        SecureRandom.uuid
-      end
-
-      protected
-
-      def bot?
-        @bot ||= request ? Browser.new(request.user_agent).bot? : false
-      end
-
-      def request
-        @request ||= @options[:request] || controller.try(:request)
-      end
-
-      def controller
-        @controller ||= @options[:controller]
-      end
-
-      def ahoy
-        @ahoy ||= @options[:ahoy]
-      end
-
-      def visit_properties
-        ahoy.visit_properties
-      end
-
-      def set_visit_properties(visit)
-        keys = visit_properties.keys
-        keys.each do |key|
-          visit.send(:"#{key}=", visit_properties[key]) if visit.respond_to?(:"#{key}=") && visit_properties[key]
-        end
-      end
-
-      def geocode(visit)
-        if Ahoy.geocode == :async
-          Ahoy::GeocodeJob.set(queue: Ahoy.job_queue).perform_later(visit)
-        end
-      end
-
-      def unique_exception_classes
-        classes = []
-        classes << ActiveRecord::RecordNotUnique if defined?(ActiveRecord::RecordNotUnique)
-        classes << PG::UniqueViolation if defined?(PG::UniqueViolation)
-        classes
-      end
-    end
-  end
-end

data/lib/ahoy/stores/bunny_store.rb

@@ -1,33 +0,0 @@
-module Ahoy
-  module Stores
-    class BunnyStore < LogStore
-      def log_visit(data)
-        post(visits_queue, data)
-      end
-
-      def log_event(data)
-        post(events_queue, data)
-      end
-
-      def channel
-        @channel ||= begin
-          conn = Bunny.new
-          conn.start
-          conn.create_channel
-        end
-      end
-
-      def post(queue, message)
-        channel.queue(queue, durable: true).publish(message.to_json)
-      end
-
-      def visits_queue
-        "ahoy_visits"
-      end
-
-      def events_queue
-        "ahoy_events"
-      end
-    end
-  end
-end

data/lib/ahoy/stores/fluentd_store.rb

@@ -1,17 +0,0 @@
-module Ahoy
-  module Stores
-    class FluentdStore < LogStore
-      def log_visit(data)
-        logger.post("visit", data)
-      end
-
-      def log_event(data)
-        logger.post("event", data)
-      end
-
-      def logger
-        @logger ||= Fluent::Logger::FluentLogger.new("ahoy", host: ENV["FLUENTD_HOST"] || "localhost", port: ENV["FLUENTD_PORT"] || 24224)
-      end
-    end
-  end
-end