appsignal 0.12.beta.31 → 0.12.beta.32

data/lib/appsignal/event_formatter/active_record/sql_formatter.rb

@@ -4,13 +4,12 @@ module Appsignal
       class SqlFormatter < Appsignal::EventFormatter
         register 'sql.active_record'
 
-        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
+        SINGLE_QUOTED_STRING = /'(.?|[^'])*'/.freeze
+        DOUBLE_QUOTED_STRING = /"(.?|[^"])*"/.freeze
+        IN_OPERATOR_CONTENT  = /(IN \()[^\)]+(\))/.freeze
+        NUMERIC              = /\d*\.?\d+/.freeze
+        REPLACEMENT          = '\1?\2'.freeze
+        SCHEMA               = 'SCHEMA'.freeze
 
         attr_reader :adapter_uses_double_quoted_table_names
 
@@ -25,23 +24,19 @@ module Appsignal
         def format(payload)
           return nil if schema_query?(payload) || !payload[:sql]
           sql_string = payload[:sql].dup
-          if adapter_uses_double_quoted_table_names
-            sql_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
-            sql_string.gsub!(SINGLE_QUOTED_DATA, SANITIZED_VALUE)
-          else
-            sql_string.gsub!(SINGLE_QUOTE, SANITIZED_VALUE)
-            sql_string.gsub!(DOUBLE_QUOTE, SANITIZED_VALUE)
-            sql_string.gsub!(QUOTED_DATA, SANITIZED_VALUE)
+          unless adapter_uses_double_quoted_table_names
+            sql_string.gsub!(DOUBLE_QUOTED_STRING, REPLACEMENT)
           end
-          sql_string.gsub!(IN_ARRAY, SANITIZED_VALUE)
-          sql_string.gsub!(NUMERIC_DATA, SANITIZED_VALUE)
+          sql_string.gsub!(SINGLE_QUOTED_STRING, REPLACEMENT)
+          sql_string.gsub!(IN_OPERATOR_CONTENT, REPLACEMENT)
+          sql_string.gsub!(NUMERIC, REPLACEMENT)
           [payload[:name], sql_string]
         end
 
         protected
 
           def schema_query?(payload)
-            payload[:name] == 'SCHEMA'
+            payload[:name] == SCHEMA
           end
 
           def connection_config

data/lib/appsignal/integrations/padrino.rb

@@ -0,0 +1,65 @@
+require 'appsignal'
+
+module Appsignal::Integrations
+  module PadrinoPlugin
+    def self.init
+      Appsignal.logger.info("Loading Padrino (#{Padrino::VERSION}) integration")
+
+      root             = Padrino.mounted_root
+      Appsignal.config = Appsignal::Config.new(root, Padrino.env)
+
+      Appsignal.start_logger(File.join(root, 'log'))
+      Appsignal.start
+    end
+  end
+end
+
+module Padrino::Routing::InstanceMethods
+  alias route_without_appsignal route!
+
+  def route!(base=settings, pass_block=nil)
+    if !Appsignal.active? || env['sinatra.static_file']
+      route_without_appsignal(base, pass_block)
+      return
+    end
+
+    transaction = Appsignal::Transaction.create(
+      SecureRandom.uuid,
+      Appsignal::Transaction::HTTP_REQUEST,
+      request
+    )
+    begin
+      ActiveSupport::Notifications.instrument('process_action.padrino') do
+        route_without_appsignal(base, pass_block)
+      end
+    rescue => error
+      transaction.set_error(error)
+      raise error
+    ensure
+      transaction.set_action(get_payload_action(request))
+      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 get_payload_action(request)
+    # Short-circut is there's no request object to obtain information from
+    return "#{settings.name}" if request.nil?
+
+    # Older versions of Padrino work with a route object
+    route_obj = defined?(request.route_obj) && request.route_obj
+    if route_obj && route_obj.respond_to?(:original_path)
+      return "#{settings.name}:#{request.route_obj.original_path}"
+    end
+
+    # Newer versions expose the action / controller on the request class
+    request_data = request.respond_to?(:action) ? request.action : request.fullpath
+    "#{settings.name}:#{request.controller}##{request_data}"
+  end
+end
+
+Padrino.after_load do
+  Appsignal::Integrations::PadrinoPlugin.init
+end

data/lib/appsignal/integrations/rails.rb

@@ -1,6 +1,8 @@
 if defined?(::Rails)
   Appsignal.logger.info("Loading Rails (#{Rails.version}) integration")
 
+  require 'appsignal/rack/rails_instrumentation'
+
   module Appsignal
     module Integrations
       class Railtie < ::Rails::Railtie
@@ -21,13 +23,13 @@ if defined?(::Rails)
 
           app.middleware.insert_before(
             ActionDispatch::RemoteIp,
-            Appsignal::Rack::Listener
+            Appsignal::Rack::RailsInstrumentation
           )
 
           if Appsignal.config.active? &&
             Appsignal.config[:enable_frontend_error_catching] == true
             app.middleware.insert_before(
-              Appsignal::Rack::Listener,
+              Appsignal::Rack::RailsInstrumentation,
               Appsignal::Rack::JSExceptionCatcher,
             )
           end

data/lib/appsignal/integrations/rake.rb

@@ -0,0 +1,30 @@
+module Rake
+  class Task
+    alias_method :invoke_without_appsignal, :invoke
+
+    def invoke(*args)
+      if Appsignal.active?
+        invoke_with_appsignal(*args)
+      else
+        invoke_without_appsignal(*args)
+      end
+    end
+
+    def invoke_with_appsignal(*args)
+      invoke_without_appsignal(*args)
+    rescue => error
+      transaction = Appsignal::Transaction.create(
+        SecureRandom.uuid,
+        Appsignal::Transaction::BACKGROUND_JOB,
+        Appsignal::Transaction::GenericRequest.new(
+          :params => args
+        )
+      )
+      transaction.set_action(name)
+      transaction.set_error(error)
+      transaction.complete!
+      sleep 0.5 # Give us some time to flush to the agent
+      raise error
+    end
+  end
+end

data/lib/appsignal/integrations/sidekiq.rb

@@ -15,7 +15,7 @@ if defined?(::Sidekiq)
         def call(worker, item, queue)
           Appsignal.monitor_transaction(
             'perform_job.sidekiq',
-            :class       => item['class'],
+            :class       => item['wrapped'] || item['class'],
             :method      => 'perform',
             :metadata    => formatted_metadata(item),
             :params      => format_args(item['args']),
@@ -48,7 +48,7 @@ if defined?(::Sidekiq)
         end
 
         def truncate(text)
-          text.size > 100 ? "#{text[0...97]}..." : text
+          text.size > 200 ? "#{text[0...197]}..." : text
         end
       end
     end

data/lib/appsignal/integrations/sinatra.rb

@@ -14,6 +14,5 @@ Appsignal.start_logger(app_settings.root)
 Appsignal.start
 
 if Appsignal.active?
-  ::Sinatra::Application.use(Appsignal::Rack::Listener)
   ::Sinatra::Application.use(Appsignal::Rack::SinatraInstrumentation)
 end

data/lib/appsignal/js_exception_transaction.rb

@@ -5,21 +5,16 @@ module Appsignal
     def initialize(data)
       @data = data
       @uuid = SecureRandom.uuid
-      @transaction_index = Appsignal::Extension.start_transaction(@uuid)
+      @transaction_index = Appsignal::Extension.start_transaction(@uuid, Appsignal::Transaction::FRONTEND)
 
-      set_base_data
+      set_action
       set_metadata
       set_error
       set_error_data
     end
 
-    def set_base_data
-      Appsignal::Extension.set_transaction_base_data(
-        @transaction_index,
-        'frontend',
-        @data['action'],
-        0
-      )
+    def set_action
+      Appsignal::Extension.set_transaction_action(@transaction_index, @data['action'])
     end
 
     def set_metadata

data/lib/appsignal/params_sanitizer.rb

@@ -25,8 +25,10 @@ module Appsignal
           sanitize_hash(value)
         when Array
           sanitize_array(value)
-        when Fixnum, String, Symbol
+        when Fixnum, String, Symbol, Float
           unmodified(value)
+        when TrueClass, FalseClass
+          stringified(value)
         else
           inspected(value)
         end
@@ -46,15 +48,16 @@ module Appsignal
         target_array
       end
 
+      def stringified(value)
+        value.to_s
+      end
+
       def unmodified(value)
         value
       end
 
       def inspected(value)
-        value.inspect
-      rescue
-        # It turns out that sometimes inspect can fail
-        "#<#{value.class.to_s}/>"
+        "#<#{value.class.to_s}>"
       end
     end
   end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -0,0 +1,41 @@
+require 'rack'
+
+module Appsignal
+  module Rack
+    class RailsInstrumentation
+      def initialize(app, options = {})
+        Appsignal.logger.debug 'Initializing Appsignal::Rack::RailsInstrumentation'
+        @app, @options = app, options
+      end
+
+      def call(env)
+        if Appsignal.active?
+          call_with_appsignal_monitoring(env)
+        else
+          @app.call(env)
+        end
+      end
+
+      def call_with_appsignal_monitoring(env)
+        request = ActionDispatch::Request.new(env)
+        transaction = Appsignal::Transaction.create(
+          env['action_dispatch.request_id'],
+          Appsignal::Transaction::HTTP_REQUEST,
+          request
+        )
+        begin
+          @app.call(env)
+        rescue => error
+          transaction.set_error(error)
+          raise error
+        ensure
+          transaction.set_http_or_background_action
+          transaction.set_http_or_background_queue_start
+          transaction.set_metadata('path', request.path)
+          transaction.set_metadata('method', request.request_method)
+          Appsignal::Transaction.complete_current!
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -9,33 +9,40 @@ module Appsignal
       end
 
       def call(env)
-        ActiveSupport::Notifications.instrument(
-          'process_action.sinatra',
-          raw_payload(env)
-        ) do |payload|
-          begin
-            @app.call(env)
-          ensure
-            # This information is available only after the
-            # request has been processed by Sinatra.
-            payload[:action] = env['sinatra.route']
-          end
+        if Appsignal.active?
+          call_with_appsignal_monitoring(env)
+        else
+          @app.call(env)
         end
-      ensure
-        # In production newer versions of Sinatra don't raise errors, but store
-        # them in the sinatra.error env var.
-        Appsignal::Transaction.current.add_exception(env['sinatra.error']) if env['sinatra.error']
       end
 
-      def raw_payload(env)
-        request = @options.fetch(:request_class, ::Sinatra::Request).new(env)
-        params = request.public_send(@options.fetch(:params_method, :params))
-        {
-          :params  => params,
-          :session => request.session,
-          :method  => request.request_method,
-          :path    => request.path
-        }
+      def call_with_appsignal_monitoring(env)
+        if @options[:params_method]
+          env[:params_method] = @options[:params_method]
+        end
+        request = @options.fetch(:request_class, Sinatra::Request).new(env)
+        transaction = Appsignal::Transaction.create(
+          SecureRandom.uuid,
+          Appsignal::Transaction::HTTP_REQUEST,
+          request
+        )
+        begin
+          ActiveSupport::Notifications.instrument('process_action.sinatra') do
+            @app.call(env)
+          end
+        rescue => error
+          transaction.set_error(error)
+          raise error
+        ensure
+          # In production newer versions of Sinatra don't raise errors, but store
+          # them in the sinatra.error env var.
+          transaction.set_error(env['sinatra.error']) if env['sinatra.error']
+          transaction.set_action(env['sinatra.route'])
+          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
     end
   end

data/lib/appsignal/subscriber.rb

@@ -1,8 +1,6 @@
 module Appsignal
   class Subscriber
-    PROCESS_ACTION_PREFIX = 'process_action'.freeze
-    PERFORM_JOB_PREFIX    = 'perform_job'.freeze
-    BLANK                 = ''.freeze
+    BLANK = ''.freeze
 
     def initialize
       subscribe
@@ -33,18 +31,13 @@ module Appsignal
 
     def start(name, id, payload)
       return unless transaction = Appsignal::Transaction.current
-
       return if transaction.paused?
+
       Appsignal::Extension.start_event(transaction.transaction_index)
     end
 
     def finish(name, id, payload)
       return unless transaction = Appsignal::Transaction.current
-
-      if name.start_with?(PROCESS_ACTION_PREFIX, PERFORM_JOB_PREFIX)
-        transaction.set_root_event(name, payload)
-      end
-
       return if transaction.paused?
 
       title, body = Appsignal::EventFormatter.format(name, payload)

data/lib/appsignal/transaction.rb

@@ -2,6 +2,7 @@ module Appsignal
   class Transaction
     HTTP_REQUEST   = 'http_request'.freeze
     BACKGROUND_JOB = 'background_job'.freeze
+    FRONTEND       = 'frontend'.freeze
 
     # Based on what Rails uses + some variables we'd like to show
     ENV_METHODS = %w(CONTENT_LENGTH AUTH_TYPE GATEWAY_INTERFACE
@@ -15,8 +16,8 @@ module Appsignal
     HTTP_PRAGMA HTTP_REFERER HTTP_X_FORWARDED_FOR HTTP_CLIENT_IP).freeze
 
     class << self
-      def create(request_id, env)
-        Thread.current[:appsignal_transaction] = Appsignal::Transaction.new(request_id, env)
+      def create(id, namespace, request, options={})
+        Thread.current[:appsignal_transaction] = Appsignal::Transaction.new(id, namespace, request, options)
       end
 
       def current
@@ -33,68 +34,74 @@ module Appsignal
       end
     end
 
-    attr_reader :request_id, :transaction_index, :process_action_event, :action, :exception,
-                :env, :fullpath, :time, :tags, :kind, :queue_start, :paused, :root_event_payload
+    attr_reader :transaction_index, :transaction_id, :namespace, :request, :paused, :tags, :options
 
-    def initialize(request_id, env)
-      @root_event_payload = nil
-      @request_id = request_id
-      @process_action_event = nil
-      @exception = nil
-      @env = env
-      @tags = {}
+    def initialize(transaction_id, namespace, request, options)
+      @transaction_id = transaction_id
+      @namespace = namespace
+      @request = request
       @paused = false
-      @queue_start = -1
-      @transaction_index = Appsignal::Extension.start_transaction(@request_id)
+      @tags = {}
+
+      @options = options
+      @options[:params_method] ||= :params
+
+      @transaction_index = Appsignal::Extension.start_transaction(@transaction_id, @namespace)
     end
 
-    def sanitized_environment
-      @sanitized_environment ||= {}
+    def pause!
+      @paused = true
     end
 
-    def sanitized_session_data
-      @sanitized_session_data ||= {}
+    def resume!
+      @paused = false
     end
 
-    def request
-      @request ||= ::Rack::Request.new(env)
+    def paused?
+      @paused == true
     end
 
     def set_tags(given_tags={})
       @tags.merge!(given_tags)
     end
 
-    def set_root_event(name, payload)
-      @root_event_payload = payload
-      if name.start_with?(Subscriber::PROCESS_ACTION_PREFIX)
-        @action = "#{@root_event_payload[:controller]}##{@root_event_payload[:action]}"
-        @kind = HTTP_REQUEST
-        set_http_queue_start
-        set_metadata('path', payload[:path])
-        set_metadata('request_format', payload[:request_format])
-        set_metadata('request_method', payload[:request_method])
-        set_metadata('status', payload[:status].to_s)
-      elsif name.start_with?(Subscriber::PERFORM_JOB_PREFIX)
-        @action = "#{@root_event_payload[:class]}##{@root_event_payload[:method]}"
-        @kind = BACKGROUND_JOB
-        set_background_queue_start
+    def set_action(action)
+      return unless action
+      Appsignal::Extension.set_transaction_action(transaction_index, action)
+    end
+
+    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('#'))
+    end
+
+    def set_queue_start(start)
+      return unless start
+      Appsignal::Extension.set_transaction_queue_start(transaction_index, start)
+    end
+
+    def set_http_or_background_queue_start
+      if namespace == HTTP_REQUEST
+        set_queue_start(http_queue_start)
+      elsif namespace == BACKGROUND_JOB
+        set_queue_start(background_queue_start)
       end
-      Appsignal::Extension.set_transaction_base_data(
-        transaction_index,
-        kind,
-        action,
-        queue_start
-      )
     end
 
     def set_metadata(key, value)
-      return unless value
+      return unless key && value
       Appsignal::Extension.set_transaction_metadata(transaction_index, key, value)
     end
 
     def set_error(error)
       return unless error
-      Appsignal.logger.debug("Adding #{error.class.name} to transaction: #{request_id}")
+      return if Appsignal.is_ignored_error?(error)
+
+      Appsignal.logger.debug("Adding #{error.class.name} to transaction: #{transaction_id}")
       Appsignal::Extension.set_transaction_error(
         transaction_index,
         error.class.name,
@@ -122,59 +129,64 @@ module Appsignal
     end
     alias_method :add_exception, :set_error
 
-    def pause!
-      @paused = true
-    end
+    class GenericRequest
+      attr_reader :env
 
-    def resume!
-      @paused = false
-    end
+      def initialize(env)
+        @env = env
+      end
 
-    def paused?
-      @paused == true
+      def params
+        env[:params]
+      end
     end
 
     protected
 
-    def set_background_queue_start
-      return unless root_event_payload
-      queue_start = root_event_payload[:queue_start]
+    def background_queue_start
+      return unless request.env
+      queue_start = request.env[:queue_start]
       return unless queue_start
-      @queue_start = (queue_start.to_f * 1000.0).to_i
+      (queue_start.to_f * 1000.0).to_i
+    end
+
+    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)
+      return if cleaned_value.empty?
+      value = cleaned_value.to_i
+      [1_000_000.0, 1_000.0].each do |factor|
+        queue_start = (value / factor).to_i
+        return queue_start if queue_start > 946_681_200 # Ok if it's later than 2000
+      end
+      nil
     end
 
     def sanitized_params
-      return unless root_event_payload
-      Appsignal::ParamsSanitizer.sanitize(root_event_payload[:params])
-    end
-
-    def set_http_queue_start
-      return unless env
-      env_var = env['HTTP_X_QUEUE_START'] || env['HTTP_X_REQUEST_START']
-      if env_var
-        cleaned_value = env_var.tr('^0-9', '')
-        unless cleaned_value.empty?
-          value = cleaned_value.to_i
-          [1_000_000.0, 1_000.0].each do |factor|
-            @queue_start = (value / factor).to_i
-            break if @queue_start > 946_681_200.0 # Ok if it's later than 2000
-          end
-        end
+      return unless Appsignal.config[:send_params]
+      return unless request.respond_to?(options[:params_method])
+      return unless params = request.send(options[:params_method])
+      if params.is_a?(Hash)
+        Appsignal::ParamsSanitizer.sanitize(params)
+      elsif params.is_a?(Array)
+        params
       end
     end
 
     def sanitized_environment
-      return unless env
+      return unless request.env
       {}.tap do |out|
         ENV_METHODS.each do |key|
-          out[key] = env[key] if env[key]
+          out[key] = request.env[key] if request.env[key]
         end
       end
     end
 
     def sanitized_session_data
-      return if Appsignal.config[:skip_session_data] || !env
-      Appsignal::ParamsSanitizer.sanitize(request.session.to_hash)
+      return if Appsignal.config[:skip_session_data] || !request.respond_to?(:session)
+      return unless session = request.session
+      Appsignal::ParamsSanitizer.sanitize(session.to_hash)
     end
 
     # Only keep tags if they meet the following criteria:
@@ -189,12 +201,11 @@ module Appsignal
     end
 
     def cleaned_backtrace(backtrace)
-      if defined?(::Rails)
+      if defined?(::Rails) && backtrace
         ::Rails.backtrace_cleaner.clean(backtrace, nil)
       else
         backtrace
       end
     end
-
   end
 end