ahoy_matey 1.5.5 → 4.2.1

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/properties.rb

@@ -1,58 +0,0 @@
-module Ahoy
-  module Properties
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def where_properties(properties)
-        relation = self
-        column_type = columns_hash["properties"].type
-        adapter_name = connection.adapter_name.downcase
-        case adapter_name
-        when /mysql/
-          if column_type == :json
-            properties.each do |k, v|
-              if v.nil?
-                v = "null"
-              elsif v == true
-                v = "true"
-              end
-
-              relation = relation.where("JSON_UNQUOTE(properties -> ?) = ?", "$.#{k.to_s}", 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/, "").gsub("+", "\\\\+")}[,}]")
-            end
-          end
-        when /postgres|postgis/
-          if column_type == :jsonb || column_type == :json
-            properties.each do |k, v|
-              relation =
-                if v.nil?
-                  relation.where("properties ->> ? IS NULL", k.to_s)
-                else
-                  relation.where("properties ->> ? = ?", k.to_s, v.as_json.to_s)
-                end
-            end
-          elsif column_type == :hstore
-            properties.each do |k, v|
-              relation =
-                if v.nil?
-                  relation.where("properties -> ? IS NULL", k.to_s)
-                else
-                  relation.where("properties -> ? = ?", k.to_s, v.to_s)
-                end
-            end
-          else
-            properties.each do |k, v|
-              relation = relation.where("properties SIMILAR TO ?", "%[{,]#{{k.to_s => v}.to_json.sub(/\A\{/, "").sub(/\}\z/, "").gsub("+", "\\\\+")}[,}]%")
-            end
-          end
-        else
-          raise "Adapter not supported: #{adapter_name}"
-        end
-        relation
-      end
-    end
-  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

data/lib/ahoy/stores/kafka_store.rb

@@ -1,40 +0,0 @@
-module Ahoy
-  module Stores
-    class KafkaStore < LogStore
-      def log_visit(data)
-        post(visits_topic, data)
-      end
-
-      def log_event(data)
-        post(events_topic, data)
-      end
-
-      def client
-        @client ||= begin
-          client = Kafka.new(
-            seed_brokers: ENV["KAFKA_URL"],
-            logger: Rails.logger
-          )
-          at_exit { client.shutdown }
-          client
-        end
-      end
-
-      def producer
-        @producer ||= client.async_producer(delivery_interval: 3)
-      end
-
-      def post(topic, data)
-        producer.produce(data.to_json, topic: topic)
-      end
-
-      def visits_topic
-        "ahoy_visits"
-      end
-
-      def events_topic
-        "ahoy_events"
-      end
-    end
-  end
-end

data/lib/ahoy/stores/kinesis_firehose_store.rb

@@ -1,42 +0,0 @@
-module Ahoy
-  module Stores
-    class KinesisFirehoseStore < LogStore
-      def log_visit(data)
-        post(visits_stream, data)
-      end
-
-      def log_event(data)
-        post(events_stream, data)
-      end
-
-      def client
-        @client ||= Aws::Firehose::Client.new(credentials)
-      end
-
-      def post(stream, data)
-        client.put_record(
-          delivery_stream_name: stream,
-          record: {
-            data: "#{data.to_json}\n"
-          }
-        )
-      end
-
-      def credentials
-        {
-          access_key_id: ENV["AWS_ACCESS_KEY_ID"],
-          secret_access_key: ENV["AWS_SECRET_ACCESS_KEY"],
-          region: "us-east-1"
-        }
-      end
-
-      def visits_stream
-        "ahoy_visits"
-      end
-
-      def events_stream
-        "ahoy_events"
-      end
-    end
-  end
-end

data/lib/ahoy/stores/log_store.rb

@@ -1,53 +0,0 @@
-module Ahoy
-  module Stores
-    class LogStore < BaseStore
-      def track_visit(options, &block)
-        data = {
-          id: ahoy.visit_id,
-          visitor_id: ahoy.visitor_id
-        }.merge(visit_properties.to_hash)
-        data[:user_id] = user.id if user
-        data[:started_at] = options[:started_at]
-
-        yield(data) if block_given?
-
-        log_visit(data)
-      end
-
-      def track_event(name, properties, options, &block)
-        data = {
-          id: options[:id],
-          name: name,
-          properties: properties,
-          visit_id: ahoy.visit_id,
-          visitor_id: ahoy.visitor_id
-        }
-        data[:user_id] = user.id if user
-        data[:time] = options[:time]
-
-        yield(data) if block_given?
-
-        log_event(data)
-      end
-
-      protected
-
-      def log_visit(data)
-        visit_logger.info data.to_json
-      end
-
-      def log_event(data)
-        event_logger.info data.to_json
-      end
-
-      # TODO disable header
-      def visit_logger
-        @visit_logger ||= ActiveSupport::Logger.new(Rails.root.join("log/visits.log"))
-      end
-
-      def event_logger
-        @event_logger ||= ActiveSupport::Logger.new(Rails.root.join("log/events.log"))
-      end
-    end
-  end
-end

data/lib/ahoy/stores/mongoid_store.rb

@@ -1,63 +0,0 @@
-module Ahoy
-  module Stores
-    class MongoidStore < BaseStore
-      def track_visit(options, &block)
-        @visit =
-          visit_model.new do |v|
-            v.id = binary(ahoy.visit_id)
-            v.visitor_id = binary(ahoy.visitor_id)
-            v.user = user if v.respond_to?(:user=) && user
-            v.started_at = options[:started_at]
-          end
-
-        set_visit_properties(visit)
-
-        yield(visit) if block_given?
-
-        visit.upsert
-        geocode(visit)
-      end
-
-      def track_event(name, properties, options, &block)
-        event =
-          event_model.new do |e|
-            e.id = binary(options[:id])
-            e.visit_id = binary(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?
-
-        event.upsert
-      end
-
-      def visit
-        @visit ||= visit_model.where(_id: binary(ahoy.visit_id)).first if ahoy.visit_id
-      end
-
-      protected
-
-      def visit_model
-        ::Visit
-      end
-
-      def event_model
-        ::Ahoy::Event
-      end
-
-      def binary(token)
-        token = token.delete("-")
-        if defined?(::BSON)
-          ::BSON::Binary.new(token, :uuid)
-        elsif defined?(::Moped::BSON)
-          ::Moped::BSON::Binary.new(:uuid, token)
-        else
-          token
-        end
-      end
-    end
-  end
-end

data/lib/ahoy/stores/nats_store.rb

@@ -1,34 +0,0 @@
-module Ahoy
-  module Stores
-    class NatsStore < LogStore
-      def log_visit(data)
-        publish(visits_subject, data)
-      end
-
-      def log_event(data)
-        publish(events_subject, data)
-      end
-
-      def publish(subject, data)
-        client.publish(subject, data.to_json)
-      end
-
-      def client
-        @client ||= begin
-          require "nats/io/client"
-          client = NATS::IO::Client.new
-          client.connect(servers: (ENV["NATS_URL"] || "nats://127.0.0.1:4222").split(","))
-          client
-        end
-      end
-
-      def visits_subject
-        "ahoy_visits"
-      end
-
-      def events_subject
-        "ahoy_events"
-      end
-    end
-  end
-end