appsignal 0.4.7 → 0.5.0

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p392

data/README.md

@@ -13,36 +13,37 @@ example
 
     tagging [2]
 
-## Event payload sanitizer
+## Postprocessing middleware
 Appsignal logs Rails
 [ActiveSupport::Notification](http://api.rubyonrails.org/classes/ActiveSupport/Notifications.html)-events
 to appsignal.com over SSL. These events contain basic metadata such as a name
-and timestamps, and additional 'payload' log data. By default,
-appsignal will transmit all payload data. If you want to restrict the amount of
-payload data that gets sent to <https://appsignal.com>, you can define your own
-event payload sanitizer in `config/environment/my_env.rb`. The
-`event_payload_sanitizer` needs to be a callable object that returns a
-JSON-serializable hash.
+and timestamps, and additional 'payload' log data. Appsignal uses a postprocessing
+middleware stack to clean up events before they get sent to appsignal.com. You
+can add your own middleware to this stack in `config/environment/my_env.rb`.
 
 ### Examples
 
-#### Pass through the entire payload unmodified (default)
+#### Minimal template
 ```ruby
-Appsignal.event_payload_sanitizer = proc { |event| event.payload }
-```
+class MiddlewareTemplate
+  def call(event)
+    # modify the event in place
+    yield # pass control to the next middleware
+    # modify the event some more
+  end
+end
 
-#### Delete the entire event payload
-```ruby
-Appsignal.event_payload_sanitizer = proc { {} }
+Appsignal.postprocessing_middleware.add MiddlewareTemplate
 ```
 
-#### Conditional modification of the payload
+#### Remove boring payloads
 ```ruby
-Appsignal.event_payload_sanitizer = proc do |event|
-  if event.name == 'interesting'
-    event.payload
-  else
-    {}
+class RemoveBoringPayload
+  def call(event)
+    unless event.name == 'interesting'
+      event.payload = {}
+    end
+    yield
   end
 end
 ```

data/appsignal.gemspec

@@ -22,12 +22,12 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
   gem.version       = Appsignal::VERSION
 
-  gem.add_dependency 'rails', '~>3'
+  gem.add_dependency 'rails', '~> 3.0'
   gem.add_dependency 'rake'
   gem.add_dependency 'json'
-  gem.add_dependency 'rack'
 
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'capistrano'
   gem.add_development_dependency 'generator_spec'
+  gem.add_development_dependency 'pry'
 end

data/lib/appsignal.rb

@@ -2,18 +2,17 @@ raise 'This appsignal gem only works with rails' unless defined?(Rails)
 
 module Appsignal
   class << self
-    attr_accessor :subscriber, :event_payload_sanitizer
+    attr_accessor :subscriber
+    attr_reader :in_memory_log
 
-    def active?
-      config && config[:active] == true
-    end
-
-    def logger
-      if Rails.root
-        @logger ||= Logger.new("#{Rails.root}/log/appsignal.log").tap do |l|
-          l.level = Logger::INFO
-        end
-      end
+    # Convenience method for adding a transaction to the queue. This queue is
+    # managed and is periodically pushed to Appsignal.
+    #
+    # @return [ true ] True.
+    #
+    # @since 0.5.0
+    def enqueue(transaction)
+      agent.enqueue(transaction)
     end
 
     def transactions
@@ -24,24 +23,48 @@ module Appsignal
       @agent ||= Appsignal::Agent.new
     end
 
+    def logger
+      @in_memory_log = StringIO.new unless @in_memory_log
+      @logger ||= Logger.new(@in_memory_log).tap do |l|
+        l.level = Logger::INFO
+      end
+    end
+
+    def flush_in_memory_log
+      Appsignal.logger << @in_memory_log.string
+    end
+
+    def logger=(l)
+      @logger = l
+    end
+
     def config
       @config ||= Appsignal::Config.new(Rails.root, Rails.env).load
     end
 
-    def event_payload_sanitizer
-      @event_payload_sanitizer ||= proc { |event| event.payload }
+    def post_processing_middleware
+      @post_processing_chain ||= PostProcessor.default_middleware
+      yield @post_processing_chain if block_given?
+      @post_processing_chain
     end
+
+    def active?
+      config && config[:active] == true
+    end
+
   end
 end
 
+require 'appsignal/agent'
+require 'appsignal/aggregator'
+require 'appsignal/auth_check'
 require 'appsignal/cli'
 require 'appsignal/config'
-require 'appsignal/transmitter'
-require 'appsignal/agent'
+require 'appsignal/exception_notification'
+require 'appsignal/listener'
 require 'appsignal/marker'
 require 'appsignal/middleware'
+require 'appsignal/railtie'
 require 'appsignal/transaction'
-require 'appsignal/exception_notification'
-require 'appsignal/auth_check'
+require 'appsignal/transmitter'
 require 'appsignal/version'
-require 'appsignal/railtie'

data/lib/appsignal/agent.rb

@@ -1,104 +1,78 @@
 module Appsignal
   class Agent
-    attr_reader :queue, :active, :sleep_time, :slowest_transactions, :transmitter
     ACTION = 'log_entries'
 
+    attr_reader :aggregator, :active, :sleep_time, :transmitter
+
     def initialize
       return unless Appsignal.active?
       @sleep_time = 60.0
-      @slowest_transactions = {}
-      @queue = []
+      @aggregator = Aggregator.new
       @retry_request = true
       @thread = Thread.new do
         while true do
-          send_queue if @queue.any?
-          sleep @sleep_time
+          send_queue if aggregator.has_transactions?
+          sleep(sleep_time)
         end
       end
       @transmitter = Transmitter.new(
-        Appsignal.config[:endpoint],
+        Appsignal.config.fetch(:endpoint),
         ACTION,
-        Appsignal.config[:api_key]
+        Appsignal.config.fetch(:api_key)
       )
       Appsignal.logger.info 'Started the Appsignal agent'
     end
 
-    def add_to_queue(transaction)
-      if !transaction.exception? && transaction.action
-        current_slowest_transaction = @slowest_transactions[transaction.action]
-        if current_slowest_transaction
-          if current_slowest_transaction.process_action_event.duration <
-             transaction.process_action_event.duration
-            current_slowest_transaction.clear_payload_and_events!
-            @slowest_transactions[transaction.action] = transaction
-          else
-            transaction.clear_payload_and_events!
-          end
-        else
-          @slowest_transactions[transaction.action] = transaction
-        end
-      end
-      @queue << transaction
+    def enqueue(transaction)
+      aggregator.add(transaction)
     end
 
     def send_queue
       Appsignal.logger.debug "Sending queue"
+      current_aggregator = aggregator
+      @aggregator = Aggregator.new
       begin
-        handle_result transmitter.transmit(queue.map(&:to_hash))
+        handle_result transmitter.transmit(current_aggregator.post_processed_queue!)
       rescue Exception => ex
-        Appsignal.logger.error "Exception while communicating with AppSignal: #{ex}"
-        handle_result nil
+        Appsignal.logger.error "#{ex.class} while sending queue: #{ex.message}"
+        Appsignal.logger.error ex.backtrace.join('\n')
+        stop_logging
       end
     end
 
+    protected
+
     def handle_result(code)
       Appsignal.logger.debug "Queue sent, response code: #{code}"
       case code.to_i
-      when 200
-        good_response
+      when 200 # ok
       when 420 # Enhance Your Calm
-        good_response
-        @sleep_time = @sleep_time * 1.5
+        @sleep_time = sleep_time * 1.5
       when 413 # Request Entity Too Large
-        good_response
-        @sleep_time = @sleep_time / 1.5
+        @sleep_time = sleep_time / 1.5
       when 429
-        Appsignal.logger.error "Too many requests sent, disengaging the agent"
+        Appsignal.logger.error "Too many requests sent"
         stop_logging
       when 406
-        Appsignal.logger.error "Your appsignal gem cannot communicate with the API anymore, please upgrade. Disengaging the agent"
+        Appsignal.logger.error "Your appsignal gem cannot communicate with "\
+          "the API anymore, please upgrade."
         stop_logging
       when 402
-        Appsignal.logger.error "Payment required, disengaging the agent"
+        Appsignal.logger.error "Payment required"
         stop_logging
       when 401
-        Appsignal.logger.error "API token cannot be authorized, disengaging the agent"
+        Appsignal.logger.error "API token cannot be authorized"
         stop_logging
       else
-        retry_once
-      end
-    end
-
-    protected
-
-    def good_response
-      @queue = []
-      @slowest_transactions = {}
-      @retry_request = true
-    end
-
-    def retry_once
-      if @retry_request
-        @retry_request = false
-      else
-        @retry_request = true
-        @queue = []
+        Appsignal.logger.error "Unknown Appsignal response code: '#{code}'"
       end
     end
 
     def stop_logging
+      Appsignal.logger.info("Disengaging the agent")
       ActiveSupport::Notifications.unsubscribe(Appsignal.subscriber)
       Thread.kill(@thread)
     end
+
   end
 end

data/lib/appsignal/aggregator.rb

@@ -0,0 +1,65 @@
+module Appsignal
+  class Aggregator
+    attr_reader :queue, :slowness_index
+
+    def initialize(queue = [], slowness_index = {})
+      @queue = queue
+      @slowness_index = slowness_index
+    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.convert_values_to_primitives!
+      end
+      queue << transaction
+    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::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
+
+require 'appsignal/aggregator/post_processor'

data/lib/appsignal/aggregator/post_processor.rb

@@ -0,0 +1,27 @@
+module Appsignal
+  class PostProcessor
+    attr_reader :transactions
+
+    def initialize(transactions)
+      @transactions = transactions
+    end
+
+    def post_processed_queue!
+      transactions.map do |transaction|
+        transaction.events.each do |event|
+          Appsignal.post_processing_middleware.invoke(event)
+        end
+        transaction.to_hash
+      end
+    end
+
+    def self.default_middleware
+      Middleware::Chain.new do |chain|
+        chain.add Appsignal::Middleware::DeleteBlanks
+        chain.add Appsignal::Middleware::ActionViewSanitizer
+        chain.add Appsignal::Middleware::ActiveRecordSanitizer
+      end
+    end
+
+  end
+end

data/lib/appsignal/config.rb

@@ -1,9 +1,16 @@
 require 'appsignal/careful_logger'
 
 module Appsignal
+
   class Config
     include Appsignal::CarefulLogger
 
+    DEFAULT_CONFIG = {
+      :ignore_exceptions => [],
+      :endpoint => 'https://push.appsignal.com/1',
+      :slow_request_threshold => 200
+    }.freeze
+
     attr_accessor :root_path, :rails_env
 
     def initialize(root_path, rails_env, logger=Appsignal.logger)
@@ -25,11 +32,9 @@ module Appsignal
         return
       end
 
-      config = {:ignore_exceptions => [],
-        :endpoint => 'https://push.appsignal.com/1',
-        :slow_request_threshold => 200
-      }.merge(config.symbolize_keys)
+      DEFAULT_CONFIG.merge(config.symbolize_keys)
     end
 
   end
+
 end

data/lib/appsignal/listener.rb

@@ -0,0 +1,30 @@
+require 'action_dispatch'
+
+module Appsignal
+  class Listener
+    def initialize(app, options = {})
+      @app, @options = app, options
+    end
+
+    def call(env)
+      Appsignal::Transaction.create(env['action_dispatch.request_id'], env)
+      @app.call(env)
+    rescue Exception => exception
+      unless in_ignored_exceptions?(exception)
+        Appsignal::Transaction.current.add_exception(
+          Appsignal::ExceptionNotification.new(env, exception)
+        )
+      end
+      raise exception
+    ensure
+      Appsignal::Transaction.current.complete!
+    end
+
+    private
+
+    def in_ignored_exceptions?(exception)
+      Array.wrap(Appsignal.config[:ignore_exceptions]).
+        include?(exception.class.name)
+    end
+  end
+end