appsignal 0.11.18 → 0.12.beta.0

data/gemfiles/padrino-0.13.gemfile

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'padrino', '~> 0.12.0'
-
-gem 'generator_spec'
-
-gemspec :path => '../'

data/gemfiles/resque.gemfile

@@ -1,5 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'resque'
-
-gemspec :path => '../'

data/lib/appsignal/agent.rb

@@ -1,217 +0,0 @@
-module Appsignal
-  class Agent
-    ACTION = 'log_entries'.freeze
-    AGGREGATOR_LIMIT = 3 # Three minutes with a sleep time of 60 seconds
-
-    attr_accessor :aggregator, :thread, :master_pid, :pid, :active, :sleep_time,
-                  :transmitter, :subscriber, :paused, :aggregator_queue, :revision,
-                  :transmission_successful
-
-    def initialize
-      return unless Appsignal.config.active?
-      if Appsignal.config.env == 'development'
-        @sleep_time = 10.0
-      else
-        @sleep_time = 60.0
-      end
-      @master_pid              = Process.pid
-      @pid                     = @master_pid
-      @aggregator              = Aggregator.new
-      @transmitter             = Transmitter.new(ACTION)
-      @aggregator_queue        = []
-      @transmission_successful = true
-
-      subscribe
-      start_thread
-      @active = true
-      Appsignal.logger.info('Started Appsignal agent')
-    end
-
-    def active?
-      !! @active
-    end
-
-    def start_thread
-      Appsignal.logger.debug('Starting agent thread')
-      @revision = ENV['APP_REVISION']
-      @thread   = Thread.new do
-        begin
-          sleep(rand(sleep_time))
-          loop do
-            if aggregator.has_transactions? || aggregator_queue.any?
-              send_queue
-            end
-            truncate_aggregator_queue
-            Appsignal.logger.debug("Sleeping #{sleep_time}")
-            sleep(sleep_time)
-          end
-        rescue Exception=>ex
-          Appsignal.logger.error "#{ex.class} in agent thread: '#{ex.message}'\n#{ex.backtrace.join("\n")}"
-        end
-      end
-    end
-
-    def restart_thread
-      Appsignal.logger.debug 'Restarting agent thread'
-      stop_thread
-      start_thread
-    end
-
-    def stop_thread
-      if @thread && @thread.alive?
-        Appsignal.logger.debug 'Stopping agent thread'
-        Thread.kill(@thread)
-      end
-    end
-
-    def subscribe
-      Appsignal.logger.debug('Subscribing to notifications')
-      # Subscribe to notifications that don't start with a !
-      @subscriber = ActiveSupport::Notifications.subscribe(/^[^!]/) do |*args|
-        # Some people abuse the notification system and send their own data over it
-        # (looking at you, active_admin), make sure we only process valid events.
-        if Appsignal::Transaction.current && args.length == 5
-          event = Appsignal::Event.event_for_instrumentation(*args)
-          if event.name.start_with?('process_action')
-            Appsignal::Transaction.current.set_process_action_event(event)
-          elsif event.name.start_with?('perform_job')
-            Appsignal::Transaction.current.set_perform_job_event(event)
-          end
-          Appsignal::Transaction.current.add_event(event)
-        end
-      end
-    end
-
-    def resubscribe
-      Appsignal.logger.debug('Resubscribing to notifications')
-      unsubscribe
-      subscribe
-    end
-
-    def unsubscribe
-      Appsignal.logger.debug('Unsubscribing from notifications')
-      ActiveSupport::Notifications.unsubscribe(@subscriber)
-      @subscriber = nil
-    end
-
-    def enqueue(transaction)
-      forked! if @pid != Process.pid
-      if Appsignal.is_ignored_action?(transaction.action)
-        Appsignal.logger.debug("Ignoring transaction: #{transaction.request_id} (#{transaction.action})")
-        return
-      end
-      aggregator.add(transaction)
-    end
-
-    def send_queue
-      Appsignal.logger.debug('Sending queue')
-      unless aggregator.has_transactions? || aggregator_queue.any?
-        return
-      end
-      # Replace aggregator while making sure no thread
-      # is adding to it's queue
-      aggregator_to_be_sent = nil
-      Thread.exclusive do
-        aggregator_to_be_sent = aggregator
-        @aggregator = Aggregator.new
-      end
-
-      begin
-        payload = Appsignal::ZippedPayload.new(aggregator_to_be_sent.post_processed_queue!)
-        add_to_aggregator_queue(payload)
-        send_aggregators
-      rescue Exception => ex
-        Appsignal.logger.error "#{ex.class} while sending queue: #{ex.message}\n#{ex.backtrace.join("\n")}"
-      end
-    end
-
-    def add_to_aggregator_queue(aggregator)
-      @aggregator_queue.unshift(aggregator)
-    end
-
-    def send_aggregators
-      @aggregator_queue.map! do |payload|
-        begin
-          if handle_result(transmitter.transmit(payload))
-            nil
-          else
-            payload
-          end
-        rescue *Transmitter::HTTP_ERRORS => ex
-          Appsignal.logger.error "#{ex} while sending aggregators"
-          payload
-        end
-      end.compact!
-      @transmission_successful = @aggregator_queue.empty?
-    end
-
-    def truncate_aggregator_queue(limit = AGGREGATOR_LIMIT)
-      return unless @aggregator_queue.length > limit
-      Appsignal.logger.error "Aggregator queue to large, removing items"
-      @aggregator_queue = @aggregator_queue.first(limit)
-    end
-
-    def forked!
-      Appsignal.logger.info('Forked worker process')
-      @active = true
-      @pid = Process.pid
-      Thread.exclusive do
-        @aggregator = Aggregator.new
-      end
-      resubscribe
-      restart_thread
-    end
-
-    def shutdown(send_current_queue=false, reason=nil)
-      Appsignal.logger.info("Shutting down agent (#{reason})")
-      @active = false
-      unsubscribe
-      stop_thread
-
-      # Only attempt to send the queue on shutdown when there are no API issues
-      if send_current_queue && @transmission_successful
-        send_queue
-      end
-    end
-
-    protected
-
-    def handle_result(code)
-      Appsignal.logger.debug "Queue sent, response code: #{code}"
-      case code.to_i
-      when 200 # ok
-        true
-      when 420 # Enhance Your Calm
-        Appsignal.logger.info 'Increasing sleep time since the server told us to'
-        @sleep_time = sleep_time * 1.5
-        true
-      when 413 # Request Entity Too Large
-        Appsignal.logger.info 'Decreasing sleep time since our last push was too large'
-        @sleep_time = sleep_time / 1.5
-        true
-      when 429
-        Appsignal.logger.error 'Too many requests sent'
-        shutdown(false, 429)
-        true
-      when 406
-        Appsignal.logger.error 'Your appsignal gem cannot communicate with the API anymore, please upgrade.'
-        shutdown(false, 406)
-        true
-      when 402
-        Appsignal.logger.error 'Payment required'
-        shutdown(false, 402)
-        true
-      when 401
-        Appsignal.logger.error 'API token cannot be authorized'
-        shutdown(false, 401)
-        true
-      when 400
-        Appsignal.logger.error 'Empty body sent'
-        true
-      else
-        Appsignal.logger.error "Unknown Appsignal response code: '#{code}'"
-        false
-      end
-    end
-  end
-end

data/lib/appsignal/aggregator.rb

@@ -1,67 +0,0 @@
-module Appsignal
-  class Aggregator
-    attr_reader :queue, :slowness_index, :counts
-
-    def initialize(queue=::ThreadSafe::Array.new, slowness_index={})
-      @queue = queue
-      @slowness_index = slowness_index
-      @counts = {:regular_request => 0, :slow_request => 0, :exception => 0}
-    end
-
-    # truncates or reduces the size of event values of the transaction, and
-    # adds it to the queue.
-    #
-    # @returns [ Array ] Array with transactions
-    def add(transaction)
-      case transaction.type
-      when :regular_request
-        transaction.truncate!
-      when :slow_request
-        pre_process_slowness!(transaction)
-      when :exception
-        transaction.clear_events!
-        transaction.convert_values_to_primitives!
-      end
-      counts[transaction.type] += 1
-      queue << transaction
-      return true
-    end
-
-    # Informs whether the queue has any transactions in it or not
-    #
-    # @returns [ Boolean ]
-    def has_transactions?
-      queue.any?
-    end
-
-    # Post process the queue and return it
-    #
-    # @returns [ Array ] Array of post processed Appsignal::Transaction objects
-    def post_processed_queue!
-      Appsignal.logger.debug("Post processing queue: #{counts.inspect}")
-      Appsignal::Aggregator::PostProcessor.new(queue).post_processed_queue!
-    end
-
-    protected
-
-    def similar_slowest(transaction)
-      slowness_index[transaction.action]
-    end
-
-    def pre_process_slowness!(transaction)
-      similar_slowest = similar_slowest(transaction)
-      if similar_slowest
-        if transaction.slower?(similar_slowest)
-          slowness_index[transaction.action] = transaction
-          transaction.convert_values_to_primitives!
-          similar_slowest.truncate!
-        else
-          transaction.truncate!
-        end
-      else
-        slowness_index[transaction.action] = transaction
-        transaction.convert_values_to_primitives!
-      end
-    end
-  end
-end

data/lib/appsignal/aggregator/middleware.rb

@@ -1,4 +0,0 @@
-require 'appsignal/aggregator/middleware/chain'
-require 'appsignal/aggregator/middleware/delete_blanks'
-require 'appsignal/aggregator/middleware/action_view_sanitizer'
-require 'appsignal/aggregator/middleware/active_record_sanitizer'

data/lib/appsignal/aggregator/middleware/action_view_sanitizer.rb

@@ -1,23 +0,0 @@
-module Appsignal
-  class Aggregator
-    module Middleware
-      class ActionViewSanitizer
-        TARGET_EVENT_CATEGORY = 'action_view'.freeze
-
-        def call(event)
-          if event.name.end_with?(TARGET_EVENT_CATEGORY)
-            identifier = event.payload[:identifier]
-            if identifier
-              event.payload[:identifier] = identifier.gsub(root_path, '')
-            end
-          end
-          yield
-        end
-
-        def root_path
-          @root_path ||= "#{Rails.root.to_s}/"
-        end
-      end
-    end
-  end
-end

data/lib/appsignal/aggregator/middleware/active_record_sanitizer.rb

@@ -1,65 +0,0 @@
-module Appsignal
-  class Aggregator
-    module Middleware
-      class ActiveRecordSanitizer
-        TARGET_EVENT_NAME = 'sql.active_record'.freeze
-
-        SINGLE_QUOTE       = /\\'/.freeze
-        DOUBLE_QUOTE       = /\\"/.freeze
-        QUOTED_DATA        = /(?:"[^"]+"|'[^']+')/.freeze
-        SINGLE_QUOTED_DATA = /(?:'[^']+')/.freeze
-        IN_ARRAY           = /(IN \()[^\)]+(\))/.freeze
-        NUMERIC_DATA       = /\b\d+\b/.freeze
-
-        SANITIZED_VALUE = '\1?\2'.freeze
-
-        def call(event)
-          if event.name == TARGET_EVENT_NAME
-            unless schema_query?(event) || adapter_uses_prepared_statements?
-              query_string = event.payload[:sql].dup
-              if query_string
-                if adapter_uses_double_quoted_table_names?
-                  query_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
-                  query_string.gsub!(SINGLE_QUOTED_DATA, SANITIZED_VALUE)
-                else
-                  query_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
-                  query_string.gsub!(DOUBLE_QUOTE, SANITIZED_VALUE)
-                  query_string.gsub!(QUOTED_DATA, SANITIZED_VALUE)
-                end
-                query_string.gsub!(IN_ARRAY, SANITIZED_VALUE)
-                query_string.gsub!(NUMERIC_DATA, SANITIZED_VALUE)
-                event.payload[:sql] = query_string
-              end
-            end
-            event.payload.delete(:connection_id)
-            event.payload.delete(:binds)
-          end
-          yield
-        end
-
-        def schema_query?(event)
-          event.payload[:name] == 'SCHEMA'
-        end
-
-        def connection_config
-          @connection_config ||= if ActiveRecord::Base.respond_to?(:connection_config)
-            ActiveRecord::Base.connection_config
-          else
-            ActiveRecord::Base.connection_pool.spec.config
-          end
-        end
-
-        def adapter_uses_double_quoted_table_names?
-          adapter = connection_config[:adapter]
-          adapter =~ /postgres/ || adapter =~ /sqlite/
-        end
-
-        def adapter_uses_prepared_statements?
-          return false unless adapter_uses_double_quoted_table_names?
-          return true if connection_config[:prepared_statements].nil?
-          connection_config[:prepared_statements]
-        end
-      end
-    end
-  end
-end

data/lib/appsignal/aggregator/middleware/chain.rb

@@ -1,101 +0,0 @@
-module Appsignal
-  class Aggregator
-    # Middleware is code configured to run before/after a message is processed.
-    # It is patterned after Rack middleware.
-    #
-    # @example To add middleware:
-    #
-    #   Appsignal.post_processing_middleware do |chain|
-    #     chain.add MyPostProcessingHook
-    #   end
-    #
-    # @example To insert immediately preceding another entry:
-    #
-    #   Appsignal.post_process_middleware do |chain|
-    #     chain.insert_before ActiveRecord, MyPostProcessingHook
-    #   end
-    #
-    # @example To insert immediately after another entry:
-    #
-    #   Appsignal.post_process_middleware do |chain|
-    #     chain.insert_after ActiveRecord, MyPostProcessingHook
-    #   end
-    #
-    # @example This is an example of a minimal middleware class:
-    #
-    #   class MySHook
-    #     def call(transaction)
-    #       puts "Before post processing"
-    #       yield
-    #       puts "After post processing"
-    #     end
-    #   end
-    #
-    module Middleware
-      class Chain
-        attr_reader :entries
-
-        def initialize
-          @entries = []
-          yield self if block_given?
-        end
-
-        def remove(klass)
-          entries.delete_if { |entry| entry.klass == klass }
-        end
-
-        def add(klass, *args)
-          entries << Entry.new(klass, *args) unless exists?(klass)
-        end
-
-        def insert_before(oldklass, newklass, *args)
-          i = entries.index { |entry| entry.klass == newklass }
-          new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
-          i = entries.find_index { |entry| entry.klass == oldklass } || 0
-          entries.insert(i, new_entry)
-        end
-
-        def insert_after(oldklass, newklass, *args)
-          i = entries.index { |entry| entry.klass == newklass }
-          new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
-          i = entries.find_index { |entry| entry.klass == oldklass } || entries.count - 1
-          entries.insert(i+1, new_entry)
-        end
-
-        def exists?(klass)
-          entries.any? { |entry| entry.klass == klass }
-        end
-
-        def retrieve
-          @retrieve ||= entries.map(&:make_new)
-        end
-
-        def clear
-          entries.clear
-        end
-
-        def invoke(*args)
-          chain = retrieve.dup
-          traverse_chain = lambda do
-            unless chain.empty?
-              chain.shift.call(*args, &traverse_chain)
-            end
-          end
-          traverse_chain.call
-        end
-      end
-
-      class Entry
-        attr_reader :klass
-        def initialize(klass, *args)
-          @klass = klass
-          @args  = args
-        end
-
-        def make_new
-          @klass.new(*@args)
-        end
-      end
-    end
-  end
-end