appsignal 2.1.0.alpha.3 → 2.1.0.beta.1

data/lib/appsignal/integrations/webmachine.rb

@@ -1,18 +1,17 @@
 module Appsignal::Integrations
   module WebmachinePlugin
     module FSM
-
       def run_with_appsignal
         transaction = Appsignal::Transaction.create(
           SecureRandom.uuid,
           Appsignal::Transaction::HTTP_REQUEST,
           request,
-          {:params_method => :query}
+          :params_method => :query
         )
 
         transaction.set_action("#{resource.class.name}##{request.method}")
 
-        Appsignal.instrument('process_action.webmachine') do
+        Appsignal.instrument("process_action.webmachine") do
           run_without_appsignal
         end
 

data/lib/appsignal/js_exception_transaction.rb

@@ -14,29 +14,29 @@ module Appsignal
     end
 
     def set_action
-      @ext.set_action(@data['action']) if @data['action']
+      @ext.set_action(@data["action"]) if @data["action"]
     end
 
     def set_metadata
       @ext.set_metadata(
-        'path', @data['path']
-      ) if @data['path']
+        "path", @data["path"]
+      ) if @data["path"]
     end
 
     def set_error
       @ext.set_error(
-        @data['name'],
-        @data['message'] || '',
-        Appsignal::Utils.data_generate(@data['backtrace'] || [])
+        @data["name"],
+        @data["message"] || "",
+        Appsignal::Utils.data_generate(@data["backtrace"] || [])
       )
     end
 
     def set_sample_data
       {
-        :params       => @data['params'],
-        :session_data => @data['session_data'],
-        :environment  => @data['environment'],
-        :tags         => @data['tags']
+        :params       => @data["params"],
+        :session_data => @data["session_data"],
+        :environment  => @data["environment"],
+        :tags         => @data["tags"]
       }.each do |key, data|
         next unless data.is_a?(Array) || data.is_a?(Hash)
         @ext.set_sample_data(

data/lib/appsignal/marker.rb

@@ -1,7 +1,7 @@
 module Appsignal
   class Marker
     attr_reader :marker_data, :config
-    ACTION = 'markers'
+    ACTION = "markers"
 
     def initialize(marker_data, config)
       @marker_data = marker_data
@@ -14,8 +14,8 @@ module Appsignal
         "revision: #{marker_data[:revision]}, user: #{marker_data[:user]}"
 
       result = transmitter.transmit(marker_data)
-      if result == '200'
-        puts 'AppSignal has been notified of this deploy!'
+      if result == "200"
+        puts "AppSignal has been notified of this deploy!"
       else
         raise "#{result} at #{transmitter.uri}"
       end

data/lib/appsignal/rack/generic_instrumentation.rb

@@ -1,11 +1,12 @@
-require 'rack'
+require "rack"
 
 module Appsignal
   module Rack
     class GenericInstrumentation
       def initialize(app, options = {})
-        Appsignal.logger.debug 'Initializing Appsignal::Rack::GenericInstrumentation'
-        @app, @options = app, options
+        Appsignal.logger.debug "Initializing Appsignal::Rack::GenericInstrumentation"
+        @app = app
+        @options = options
       end
 
       def call(env)
@@ -24,20 +25,20 @@ module Appsignal
           request
         )
         begin
-          Appsignal.instrument('process_action.generic') do
+          Appsignal.instrument("process_action.generic") do
             @app.call(env)
           end
         rescue => error
           transaction.set_error(error)
           raise error
         ensure
-          if env['appsignal.route']
-            transaction.set_action(env['appsignal.route'])
+          if env["appsignal.route"]
+            transaction.set_action(env["appsignal.route"])
           else
-            transaction.set_action('unknown')
+            transaction.set_action("unknown")
           end
-          transaction.set_metadata('path', request.path)
-          transaction.set_metadata('method', request.request_method)
+          transaction.set_metadata("path", request.path)
+          transaction.set_metadata("method", request.request_method)
           transaction.set_http_or_background_queue_start
           Appsignal::Transaction.complete_current!
         end

data/lib/appsignal/rack/js_exception_catcher.rb

@@ -2,15 +2,16 @@ module Appsignal
   module Rack
     class JSExceptionCatcher
       def initialize(app, options = {})
-        Appsignal.logger.debug 'Initializing Appsignal::Rack::JSExceptionCatcher'
-        @app, @options = app, options
+        Appsignal.logger.debug "Initializing Appsignal::Rack::JSExceptionCatcher"
+        @app = app
+        @options = options
       end
 
       def call(env)
-        if env['PATH_INFO'] == Appsignal.config[:frontend_error_catching_path]
-          body = JSON.parse(env['rack.input'].read)
+        if env["PATH_INFO"] == Appsignal.config[:frontend_error_catching_path]
+          body = JSON.parse(env["rack.input"].read)
 
-          if body['name'].is_a?(String) && body['name'].length > 0
+          if body["name"].is_a?(String) && !body["name"].empty?
             transaction = JSExceptionTransaction.new(body)
             transaction.complete!
             code = 200
@@ -19,7 +20,7 @@ module Appsignal
             code = 422
           end
 
-          return [code, {}, []]
+          [code, {}, []]
         else
           @app.call(env)
         end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -1,11 +1,12 @@
-require 'rack'
+require "rack"
 
 module Appsignal
   module Rack
     class RailsInstrumentation
       def initialize(app, options = {})
-        Appsignal.logger.debug 'Initializing Appsignal::Rack::RailsInstrumentation'
-        @app, @options = app, options
+        Appsignal.logger.debug "Initializing Appsignal::Rack::RailsInstrumentation"
+        @app = app
+        @options = options
       end
 
       def call(env)
@@ -30,19 +31,19 @@ module Appsignal
           transaction.set_error(error)
           raise error
         ensure
-          controller = env['action_controller.instance']
+          controller = env["action_controller.instance"]
           if controller
-            transaction.set_action("#{controller.class.to_s}##{controller.action_name}")
+            transaction.set_action("#{controller.class}##{controller.action_name}")
           end
           transaction.set_http_or_background_queue_start
-          transaction.set_metadata('path', request.path)
-          transaction.set_metadata('method', request.request_method)
+          transaction.set_metadata("path", request.path)
+          transaction.set_metadata("method", request.request_method)
           Appsignal::Transaction.complete_current!
         end
       end
 
       def request_id(env)
-        env['action_dispatch.request_id'] || SecureRandom.uuid
+        env["action_dispatch.request_id"] || SecureRandom.uuid
       end
     end
   end

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -1,4 +1,4 @@
-require 'rack'
+require "rack"
 
 module Appsignal
   module Rack
@@ -9,9 +9,10 @@ module Appsignal
     # `use Appsignal::Rack::SinatraBaseInstrumentation` automatically.
     class SinatraInstrumentation
       def initialize(app, options = {})
-        @app, @options = app, options
-        Appsignal.logger.warn 'Please remove Appsignal::Rack::SinatraInstrumentation '\
-          'from your Sinatra::Base class. This is no longer needed.'
+        @app = app
+        @options = options
+        Appsignal.logger.warn "Please remove Appsignal::Rack::SinatraInstrumentation "\
+          "from your Sinatra::Base class. This is no longer needed."
       end
 
       def call(env)
@@ -27,8 +28,9 @@ module Appsignal
       attr_reader :raise_errors_on
 
       def initialize(app, options = {})
-        Appsignal.logger.debug 'Initializing Appsignal::Rack::SinatraInstrumentation'
-        @app, @options = app, options
+        Appsignal.logger.debug "Initializing Appsignal::Rack::SinatraInstrumentation"
+        @app = app
+        @options = options
         @raise_errors_on = raise_errors?(@app)
       end
 
@@ -49,10 +51,10 @@ module Appsignal
           SecureRandom.uuid,
           Appsignal::Transaction::HTTP_REQUEST,
           request,
-          {:force => @options.include?(:force) && @options[:force]}
+          :force => @options.include?(:force) && @options[:force]
         )
         begin
-          Appsignal.instrument('process_action.sinatra') do
+          Appsignal.instrument("process_action.sinatra") do
             @app.call(env)
           end
         rescue => error
@@ -61,25 +63,25 @@ module Appsignal
         ensure
           # If raise_error is off versions of Sinatra don't raise errors, but store
           # them in the sinatra.error env var.
-          if !@raise_errors_on && env['sinatra.error'] && !env['sinatra.skip_appsignal_error']
-            transaction.set_error(env['sinatra.error'])
+          if !@raise_errors_on && env["sinatra.error"] && !env["sinatra.skip_appsignal_error"]
+            transaction.set_error(env["sinatra.error"])
           end
           transaction.set_action(action_name(env))
-          transaction.set_metadata('path', request.path)
-          transaction.set_metadata('method', request.request_method)
+          transaction.set_metadata("path", request.path)
+          transaction.set_metadata("method", request.request_method)
           transaction.set_http_or_background_queue_start
           Appsignal::Transaction.complete_current!
         end
       end
 
       def action_name(env)
-        return unless env['sinatra.route']
+        return unless env["sinatra.route"]
 
-        if env['SCRIPT_NAME']
-          method, route = env['sinatra.route'].split(" ")
-          "#{method} #{env['SCRIPT_NAME']}#{route}"
+        if env["SCRIPT_NAME"]
+          method, route = env["sinatra.route"].split(" ")
+          "#{method} #{env["SCRIPT_NAME"]}#{route}"
         else
-          env['sinatra.route']
+          env["sinatra.route"]
         end
       end
 

data/lib/appsignal/rack/streaming_listener.rb

@@ -3,8 +3,9 @@ module Appsignal
   module Rack
     class StreamingListener
       def initialize(app, options = {})
-        Appsignal.logger.debug 'Initializing Appsignal::Rack::StreamingListener'
-        @app, @options = app, options
+        Appsignal.logger.debug "Initializing Appsignal::Rack::StreamingListener"
+        @app = app
+        @options = options
       end
 
       def call(env)
@@ -25,16 +26,16 @@ module Appsignal
 
         # Instrument a `process_action`, to set params/action name
         status, headers, body =
-          Appsignal.instrument('process_action.rack') do
+          Appsignal.instrument("process_action.rack") do
             begin
               @app.call(env)
             rescue Exception => e
               transaction.set_error(e)
               raise e
             ensure
-              transaction.set_action(env['appsignal.action'])
-              transaction.set_metadata('path', request.path)
-              transaction.set_metadata('method', request.request_method)
+              transaction.set_action(env["appsignal.action"])
+              transaction.set_metadata("path", request.path)
+              transaction.set_metadata("method", request.request_method)
               transaction.set_http_or_background_queue_start
             end
           end
@@ -47,8 +48,8 @@ module Appsignal
 
   class StreamWrapper
     def initialize(stream, transaction)
-       @stream      = stream
-       @transaction = transaction
+      @stream = stream
+      @transaction = transaction
     end
 
     def each

data/lib/appsignal/system.rb

@@ -5,31 +5,33 @@ module Appsignal
     end
 
     def self.heroku?
-      ENV.key? 'DYNO'.freeze
+      ENV.key? "DYNO".freeze
     end
 
     module Container
-      CGROUP_FILE = '/proc/self/cgroup'.freeze
+      CGROUP_FILE = "/proc/self/cgroup".freeze
 
-      def self.id
-        case cgroups
-        when %r{docker[-|/]([0-9a-f]+)}
-          $1
-        when %r{lxc/([0-9a-f-]+)$} # LXC / Heroku
-          $1
+      class << self
+        def id
+          case cgroups
+          when %r{docker[-|/]([0-9a-f]+)}
+            $1
+          when %r{lxc/([0-9a-f-]+)$} # LXC / Heroku
+            $1
+          end
         end
-      end
 
-      private
+        private
 
-      def self.cgroups
-        file = CGROUP_FILE
-        return unless File.exist? file
+        def cgroups
+          file = CGROUP_FILE
+          return unless File.exist? file
 
-        File.read(file)
-      rescue SystemCallError => e
-        Appsignal.logger.debug "Unable to read '#{file}' to determine cgroup"
-        Appsignal.logger.debug e
+          File.read(file)
+        rescue SystemCallError => e
+          Appsignal.logger.debug "Unable to read '#{file}' to determine cgroup"
+          Appsignal.logger.debug e
+        end
       end
     end
   end

data/lib/appsignal/transaction.rb

@@ -1,26 +1,29 @@
-require 'json'
+require "json"
 
 module Appsignal
   class Transaction
-    HTTP_REQUEST   = 'http_request'.freeze
-    BACKGROUND_JOB = 'background_job'.freeze
-    FRONTEND       = 'frontend'.freeze
-    BLANK          = ''.freeze
+    HTTP_REQUEST   = "http_request".freeze
+    BACKGROUND_JOB = "background_job".freeze
+    FRONTEND       = "frontend".freeze
+    BLANK          = "".freeze
 
     # Based on what Rails uses + some variables we'd like to show
-    ENV_METHODS = %w(CONTENT_LENGTH AUTH_TYPE GATEWAY_INTERFACE
-    PATH_TRANSLATED REMOTE_HOST REMOTE_IDENT REMOTE_USER REMOTE_ADDR
-    REQUEST_METHOD SERVER_NAME SERVER_PORT SERVER_PROTOCOL REQUEST_URI PATH_INFO
-
-    HTTP_X_REQUEST_START HTTP_X_MIDDLEWARE_START HTTP_X_QUEUE_START
-    HTTP_X_QUEUE_TIME HTTP_X_HEROKU_QUEUE_WAIT_TIME HTTP_X_APPLICATION_START
-    HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING HTTP_ACCEPT_LANGUAGE
-    HTTP_CACHE_CONTROL HTTP_CONNECTION HTTP_USER_AGENT HTTP_FROM HTTP_NEGOTIATE
-    HTTP_PRAGMA HTTP_REFERER HTTP_X_FORWARDED_FOR HTTP_CLIENT_IP HTTP_RANGE
-    HTTP_X_AUTH_TOKEN)
+    ENV_METHODS = %w(
+      CONTENT_LENGTH AUTH_TYPE GATEWAY_INTERFACE
+      PATH_TRANSLATED REMOTE_HOST REMOTE_IDENT REMOTE_USER REMOTE_ADDR
+      REQUEST_METHOD SERVER_NAME SERVER_PORT SERVER_PROTOCOL REQUEST_URI
+      PATH_INFO
+
+      HTTP_X_REQUEST_START HTTP_X_MIDDLEWARE_START HTTP_X_QUEUE_START
+      HTTP_X_QUEUE_TIME HTTP_X_HEROKU_QUEUE_WAIT_TIME HTTP_X_APPLICATION_START
+      HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING HTTP_ACCEPT_LANGUAGE
+      HTTP_CACHE_CONTROL HTTP_CONNECTION HTTP_USER_AGENT HTTP_FROM
+      HTTP_NEGOTIATE HTTP_PRAGMA HTTP_REFERER HTTP_X_FORWARDED_FOR
+      HTTP_CLIENT_IP HTTP_RANGE HTTP_X_AUTH_TOKEN
+    )
 
     class << self
-      def create(id, namespace, request, options={})
+      def create(id, namespace, request, options = {})
         # Allow middleware to force a new transaction
         if options.include?(:force) && options[:force]
           Thread.current[:appsignal_transaction] = nil
@@ -58,7 +61,7 @@ module Appsignal
 
     attr_reader :ext, :transaction_id, :namespace, :request, :paused, :tags, :options, :discarded
 
-    def initialize(transaction_id, namespace, request, options={})
+    def initialize(transaction_id, namespace, request, options = {})
       @transaction_id = transaction_id
       @namespace = namespace
       @request = request
@@ -82,7 +85,7 @@ module Appsignal
 
     def complete
       if discarded?
-        Appsignal.logger.debug('Skipping transaction because it was manually discarded.'.freeze)
+        Appsignal.logger.debug("Skipping transaction because it was manually discarded.".freeze)
         return
       end
       if @ext.finish(self.class.garbage_collection_profiler.total_time)
@@ -119,7 +122,7 @@ module Appsignal
       @store[key]
     end
 
-    def set_tags(given_tags={})
+    def set_tags(given_tags = {})
       @tags.merge!(given_tags)
     end
 
@@ -128,13 +131,13 @@ module Appsignal
       @ext.set_action(action)
     end
 
-    def set_http_or_background_action(from=request.params)
+    def set_http_or_background_action(from = request.params)
       return unless from
       group_and_action = [
         from[:controller] || from[:class],
         from[:action] || from[:method]
       ]
-      set_action(group_and_action.compact.join('#'))
+      set_action(group_and_action.compact.join("#"))
     end
 
     def set_queue_start(start)
@@ -182,7 +185,6 @@ module Appsignal
     def set_error(error)
       return unless error
       return unless Appsignal.active?
-      return if Appsignal.is_ignored_error?(error)
 
       backtrace = cleaned_backtrace(error.backtrace)
       @ext.set_error(
@@ -197,7 +199,7 @@ module Appsignal
       @ext.start_event(self.class.garbage_collection_profiler.total_time)
     end
 
-    def finish_event(name, title, body, body_format=Appsignal::EventFormatter::DEFAULT)
+    def finish_event(name, title, body, body_format = Appsignal::EventFormatter::DEFAULT)
       @ext.finish_event(
         name,
         title || BLANK,
@@ -207,7 +209,7 @@ module Appsignal
       )
     end
 
-    def record_event(name, title, body, duration, body_format=Appsignal::EventFormatter::DEFAULT)
+    def record_event(name, title, body, duration, body_format = Appsignal::EventFormatter::DEFAULT)
       @ext.record_event(
         name,
         title || BLANK,
@@ -217,7 +219,7 @@ module Appsignal
       )
     end
 
-    def instrument(name, title=nil, body=nil, body_format=Appsignal::EventFormatter::DEFAULT)
+    def instrument(name, title = nil, body = nil, body_format = Appsignal::EventFormatter::DEFAULT)
       start_event
       r = yield
       finish_event(name, title, body, body_format)
@@ -238,23 +240,40 @@ module Appsignal
 
     protected
 
+    # Returns calculated background queue start time in milliseconds, based on
+    # environment values.
+    #
+    # @return [nil] if no {#environment} is present.
+    # @return [nil] if there is no `:queue_start` in the {#environment}.
+    # @return [Integer]
     def background_queue_start
-      return unless request.env
-      return unless queue_start = request.env[:queue_start]
+      env = environment
+      return unless env
+      queue_start = env[:queue_start]
+      return unless queue_start
+
       (queue_start.to_f * 1000.0).to_i
     end
 
+    # Returns HTTP queue start time in milliseconds.
+    #
+    # @return [nil] if no queue start time is found.
+    # @return [nil] if begin time is too low to be plausible.
+    # @return [Integer] queue start in milliseconds.
     def http_queue_start
-      return unless request.env
-      return unless env_var = request.env['HTTP_X_QUEUE_START'.freeze] || request.env['HTTP_X_REQUEST_START'.freeze]
-      cleaned_value = env_var.tr('^0-9'.freeze, ''.freeze)
+      env = environment
+      return unless env
+      env_var = env["HTTP_X_QUEUE_START".freeze] || env["HTTP_X_REQUEST_START".freeze]
+      return unless env_var
+      cleaned_value = env_var.tr("^0-9".freeze, "".freeze)
       return if cleaned_value.empty?
+
       value = cleaned_value.to_i
       if value > 4_102_441_200_000
-        # Value is in microseconds
+        # Value is in microseconds. Transform to milliseconds.
         value / 1_000
       elsif value < 946_681_200_000
-        # Value is to low to be plausible
+        # Value is too low to be plausible
         nil
       else
         # Value is in milliseconds
@@ -283,24 +302,62 @@ module Appsignal
       Appsignal::Utils::ParamsSanitizer.sanitize params, options
     end
 
+    # Returns sanitized environment for a transaction.
+    #
+    # The environment of a transaction can contain a lot of information, not
+    # all of it useful for debugging.
+    #
+    # Only the values from the keys specified in `ENV_METHODS` are returned.
+    #
+    # @return [nil] if no environment is present.
+    # @return [Hash<String, Object>]
     def sanitized_environment
-      return unless request.env
+      env = environment
+      return if env.empty?
+
       {}.tap do |out|
         ENV_METHODS.each do |key|
-          out[key] = request.env[key] if request.env[key]
+          out[key] = env[key] if env[key]
         end
       end
     end
 
+    # Returns sanitized session data.
+    #
+    # The session data is sanitized by the {Appsignal::Utils::ParamsSanitizer}.
+    #
+    # @return [nil] if `:skip_session_data` config is set to `true`.
+    # @return [nil] if the {#request} object doesn't respond to `#session`.
+    # @return [nil] if the {#request} session data is `nil`.
+    # @return [Hash<String, Object>]
     def sanitized_session_data
-      return if Appsignal.config[:skip_session_data] || !request.respond_to?(:session)
-      return unless session = request.session
+      return if Appsignal.config[:skip_session_data] ||
+          !request.respond_to?(:session)
+      session = request.session
+      return unless session
+
       Appsignal::Utils::ParamsSanitizer.sanitize(session.to_hash)
     end
 
+    # Returns metadata from the environment.
+    #
+    # @return [nil] if no `:metadata` key is present in the {#environment}.
+    # @return [Hash<String, Object>]
     def metadata
-      return unless request.env
-      request.env[:metadata]
+      environment[:metadata]
+    end
+
+    # Returns the environment for a transaction.
+    #
+    # Returns an empty Hash when the {#request} object doesn't listen to the
+    # `#env` method or the `#env` is nil.
+    #
+    # @return [Hash<String, Object>]
+    def environment
+      return {} unless request.respond_to?(:env)
+      return {} unless request.env
+
+      request.env
     end
 
     # Only keep tags if they meet the following criteria:
@@ -310,7 +367,7 @@ module Appsignal
     def sanitized_tags
       @tags.select do |k, v|
         (k.is_a?(Symbol) || k.is_a?(String) && k.length <= 100) &&
-          (((v.is_a?(Symbol) || v.is_a?(String)) && v.length <= 100) || (v.is_a?(Integer)))
+          (((v.is_a?(Symbol) || v.is_a?(String)) && v.length <= 100) || v.is_a?(Integer))
       end
     end
 
@@ -329,7 +386,7 @@ module Appsignal
       end
 
       # Instrument should still yield
-      def instrument(*args)
+      def instrument(*_args)
         yield
       end