scout_apm 2.6.9 → 2.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54f1c7e07f92a0d5d67a22354b0273c4894e8408ec00bcdada275457ed2f00f2
-  data.tar.gz: 50cf2d441c948e769b2f2222895c84aadb0a5e3e3f75d16e647a2096a86551e4
+  metadata.gz: 503d33cb7c689cb239c328bee4ba2a1df380df703f3e3a6f5f843676b9bff0e4
+  data.tar.gz: 444e240dc8c4922ee932684c1c10b3fb5d658e96228c901b33a9a5ca3cb1e469
 SHA512:
-  metadata.gz: 27a012457a6871cdbed206f2a55914163571e81af1b1f6253079c2fe9954354a9888b59627d832f3635a536ddf3f331c066b2bc4e053956f5135c706ffea1a17
-  data.tar.gz: cfc5d80fb3b0ccebc2e78246a394a23a8e16d52a89868cff024931d6ce5b3539aafc42ef6f491105db43f8c544750b270cbbc7cc1fed556ab543bb0d963f1c75
+  metadata.gz: 715c6a3f044d2091207667fc6a9857573da528cf03ee5d64ccb758c10ec387b49829a891ae43bb51b444077c898f57fc73257f2d963407820ed7114fdedb52c4
+  data.tar.gz: 373b60dc42e0417e6003698c143138ff50024802285ff3754cc706efc1bc305a941fddbe27e6a471d8f09b3ffc84b5a3cfb43e57a1715968d7cac47ee069f5b3

data/CHANGELOG.markdown

@@ -1,3 +1,7 @@
+# 2.6.10
+
+* Fix an edge case in JSON serialization (#360)
+
 # 2.6.9
 
 * Add `ssl_cert_file` config option (#352)

data/lib/scout_apm.rb

@@ -186,6 +186,16 @@ require 'scout_apm/tasks/support'
 require 'scout_apm/extensions/config'
 require 'scout_apm/extensions/transaction_callback_payload'
 
+require 'scout_apm/error_service'
+require 'scout_apm/error_service/middleware'
+require 'scout_apm/error_service/notifier'
+require 'scout_apm/error_service/sidekiq'
+require 'scout_apm/error_service/ignored_exceptions'
+require 'scout_apm/error_service/error_buffer'
+require 'scout_apm/error_service/error_record'
+require 'scout_apm/error_service/periodic_work'
+require 'scout_apm/error_service/payload'
+
 if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR >= 3 && defined?(Rails::Railtie)
   module ScoutApm
     class Railtie < Rails::Railtie
@@ -205,6 +215,11 @@ if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR
           ScoutApm::Agent.instance.context.logger.debug("AutoInstruments is disabled.")
         end
 
+        if ScoutApm::Agent.instance.context.config.value("errors_enabled")
+          app.config.middleware.insert_after ActionDispatch::DebugExceptions, ScoutApm::ErrorService::Middleware
+          ScoutApm::ErrorService::Sidekiq.new.install
+        end
+
         # Install the middleware every time in development mode.
         # The middleware is a noop if dev_trace is not enabled in config
         if Rails.env.development?

data/lib/scout_apm/agent.rb

@@ -66,6 +66,7 @@ module ScoutApm
 
       if context.started?
         start_background_worker unless background_worker_running?
+        start_error_service_background_worker unless error_service_background_worker_running?
         return
       end
 
@@ -81,6 +82,7 @@ module ScoutApm
       @app_server_load ||= AppServerLoad.new(context).run
 
       start_background_worker
+      start_error_service_background_worker
     end
 
     def instrument_manager
@@ -198,5 +200,25 @@ module ScoutApm
         @background_worker               &&
         @background_worker.running?
     end
+
+    # seconds to batch error reports
+    ERROR_SEND_FREQUENCY = 5
+    def start_error_service_background_worker
+      periodic_work = ScoutApm::ErrorService::PeriodicWork.new(context)
+
+      @error_service_background_worker = ScoutApm::BackgroundWorker.new(context, ERROR_SEND_FREQUENCY)
+      @error_service_background_worker_thread = Thread.new do
+        @error_service_background_worker.start { 
+          periodic_work.run
+        }
+      end
+    end
+
+    def error_service_background_worker_running?
+      @error_service_background_worker_thread          &&
+        @error_service_background_worker_thread.alive? &&
+        @error_service_background_worker               &&
+        @error_service_background_worker.running?
+    end
   end
 end

data/lib/scout_apm/agent_context.rb

@@ -142,6 +142,18 @@ module ScoutApm
       config.value('dev_trace') && environment.env == "development"
     end
 
+    ###################
+    #  Error Service  #
+    ###################
+
+    def error_buffer
+      @error_buffer ||= ScoutApm::ErrorService::ErrorBuffer.new(self)
+    end
+
+    def ignored_exceptions
+      @ignored_exceptions ||= ScoutApm::ErrorService::IgnoredExceptions.new(self, config.value('errors_ignored_exceptions'))
+    end
+
     #############
     #  Setters  #
     #############

data/lib/scout_apm/config.rb

@@ -80,7 +80,13 @@ module ScoutApm
         'instrument_http_url_length',
         'timeline_traces',
         'auto_instruments',
-        'auto_instruments_ignore'
+        'auto_instruments_ignore',
+
+        # Error Service Related Configuration
+        'errors_enabled',
+        'errors_ignored_exceptions',
+        'errors_filtered_params',
+        'errors_host',
     ]
 
     ################################################################################
@@ -176,6 +182,9 @@ module ScoutApm
       'timeline_traces' => BooleanCoercion.new,
       'auto_instruments' => BooleanCoercion.new,
       'auto_instruments_ignore' => JsonCoercion.new,
+      'errors_enabled' => BooleanCoercion.new,
+      'errors_ignored_exceptions' => JsonCoercion.new,
+      'errors_filtered_params' => JsonCoercion.new,
     }
 
 
@@ -286,7 +295,11 @@ module ScoutApm
         'timeline_traces' => true,
         'auto_instruments' => false,
         'auto_instruments_ignore' => [],
-        'ssl_cert_file' => File.join( File.dirname(__FILE__), *%w[.. .. data cacert.pem] )
+        'ssl_cert_file' => File.join( File.dirname(__FILE__), *%w[.. .. data cacert.pem] ),
+        'errors_enabled' => false,
+        'errors_ignored_exceptions' => %w(ActiveRecord::RecordNotFound ActionController::RoutingError),
+        'errors_filtered_params' => %w(password s3-key),
+        'errors_host' => 'https://errors.scoutapm.com',
       }.freeze
 
       def value(key)

data/lib/scout_apm/error.rb

@@ -0,0 +1,27 @@
+# Public API for the Scout Error Monitoring service
+#
+# See-Also ScoutApm::Transaction and ScoutApm::Tracing for APM related APIs
+module ScoutApm
+  module Error
+    # Capture an exception, optionally with an environment hash. This may be a
+    # Rack environment, but is not required.
+    def self.capture(exception, env={})
+      context = ScoutApm::Agent.instance.context
+
+      # Skip if error monitoring isn't enabled at all
+      if ! context.config.value("errors_enabled")
+        return false
+      end
+
+      # Skip if this one error is ignored
+      if context.ignored_exceptions.ignored?(exception)
+        return false
+      end
+
+      # Capture the error for further processing and shipping
+      context.error_buffer.capture(exception, env)
+
+      return true
+    end
+  end
+end

data/lib/scout_apm/error_service.rb

@@ -0,0 +1,32 @@
+require "net/http"
+require "net/https"
+require "uri"
+
+module ScoutApm
+  module ErrorService
+    API_VERSION = "1"
+
+    HEADERS = {
+      "Content-type" => "application/json",
+      "Accept" => "application/json"
+    }
+
+    # Public API to force a given exception to be captured.
+    # Still obeys the ignore list
+    # Used internally by SidekiqException
+    def self.capture(exception, params = {})
+      return if disabled?
+      return if ScoutApm::Agent.instance.context.ignored_exceptions.ignore?(exception)
+
+      context.errors_buffer.capture(exception, env)
+    end
+
+    def self.enabled?
+      ScoutApm::Agent.instance.context.config.value("errors_enabled")
+    end
+
+    def self.disabled?
+      !enabled?
+    end
+  end
+end

data/lib/scout_apm/error_service/error_buffer.rb

@@ -0,0 +1,39 @@
+# Holds onto exceptions, and moves them forward to shipping when appropriate
+module ScoutApm
+  module ErrorService
+    class ErrorBuffer
+      include Enumerable
+
+      attr_reader :agent_context
+
+      def initialize(agent_context)
+        @agent_context = agent_context
+        @error_records = []
+        @mutex = Monitor.new
+      end
+
+      def capture(exception, env)
+        context = ScoutApm::Context.current
+
+        @mutex.synchronize {
+          @error_records << ErrorRecord.new(agent_context, exception, env, context)
+        }
+      end
+
+      def get_and_reset_error_records
+        @mutex.synchronize {
+          ret = @error_records
+          @error_records = []
+          ret
+        }
+      end
+
+      # Enables enumerable - for count and each and similar methods
+      def each
+        @error_records.each do |error_record|
+          yield error_record
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/error_record.rb

@@ -0,0 +1,211 @@
+module ScoutApm
+  module ErrorService
+    # Converts the raw error data captured into the captured data, and holds it
+    # until it's ready to be reported.
+    class ErrorRecord
+      attr_reader :exception_class
+      attr_reader :message
+      attr_reader :request_uri
+      attr_reader :request_params
+      attr_reader :request_session
+      attr_reader :environment
+      attr_reader :trace
+      attr_reader :request_components
+      attr_reader :context
+
+      def initialize(agent_context, exception, env, context=nil)
+        @agent_context = agent_context
+
+        @context = if context
+          context.to_hash
+        else
+          {}
+        end
+
+        @exception_class = LengthLimit.new(exception.class.name).to_s
+        @message = LengthLimit.new(exception.message, 100).to_s
+        @request_uri = LengthLimit.new(rack_request_url(env), 200).to_s
+        @request_params = clean_params(env["action_dispatch.request.parameters"])
+        @request_session = clean_params(session_data(env))
+        @environment = clean_params(strip_env(env))
+        @trace = clean_backtrace(exception.backtrace)
+        @request_components = components(env)
+      end
+
+      # TODO: This is rails specific
+      def components(env)
+        components = {}
+        unless env["action_dispatch.request.parameters"].nil?
+          components[:controller] = env["action_dispatch.request.parameters"][:controller] || nil
+          components[:action] = env["action_dispatch.request.parameters"][:action] || nil
+          components[:module] = env["action_dispatch.request.parameters"][:module] || nil
+        end
+
+        # For background workers like sidekiq
+        # TODO: extract data creation for background jobs
+        components[:controller] ||= env[:custom_controller]
+
+        components
+      end
+
+      # TODO: Can I use the same thing we use in traces?
+      def rack_request_url(env)
+        protocol = rack_scheme(env)
+        protocol = protocol.nil? ? "" : "#{protocol}://"
+
+        host = env["SERVER_NAME"] || ""
+        path = env["REQUEST_URI"] || ""
+        port = env["SERVER_PORT"] || "80"
+        port = ["80", "443"].include?(port.to_s) ? "" : ":#{port}"
+
+        protocol.to_s + host.to_s + port.to_s + path.to_s
+      end
+
+      def rack_scheme(env)
+        if env["HTTPS"] == "on"
+          "https"
+        elsif env["HTTP_X_FORWARDED_PROTO"]
+          env["HTTP_X_FORWARDED_PROTO"].split(",")[0]
+        else
+          env["rack.url_scheme"]
+        end
+      end
+
+      # TODO: This name is too vague
+      def clean_params(params)
+        return if params.nil?
+
+        normalized = normalize_data(params)
+        filter_params(normalized)
+      end
+
+      # TODO: When was backtrace_cleaner introduced?
+      def clean_backtrace(backtrace)
+        if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+          Rails.backtrace_cleaner.send(:filter, backtrace)
+        else
+          backtrace
+        end
+      end
+
+      # Deletes params from env
+      #
+      # These are not configurable, and will leak PII info up to Scout if
+      # allowed through. Things like specific parameters can be exposed with
+      # the ScoutApm::Context interface.
+      KEYS_TO_REMOVE = [
+        "rack.request.form_hash",
+        "rack.request.form_vars",
+        "async.callback",
+
+        # Security related items
+        "action_dispatch.secret_key_base",
+        "action_dispatch.http_auth_salt",
+        "action_dispatch.signed_cookie_salt",
+        "action_dispatch.encrypted_cookie_salt",
+        "action_dispatch.encrypted_signed_cookie_salt",
+        "action_dispatch.authenticated_encrypted_cookie_salt",
+
+        # Raw data from the URL & parameters. Would bypass our normal params filtering
+        "QUERY_STRING",
+        "REQUEST_URI",
+        "REQUEST_PATH",
+        "ORIGINAL_FULLPATH",
+        "action_dispatch.request.query_parameters",
+        "action_dispatch.request.parameters",
+        "rack.request.query_string",
+        "rack.request.query_hash",
+      ]
+      def strip_env(env)
+        env.reject { |k, v| KEYS_TO_REMOVE.include?(k) }
+      end
+
+      def session_data(env)
+        session = env["action_dispatch.request.session"]
+        return if session.nil?
+
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      # TODO: Rename and make this clearer. I think it maps over the whole tree of a hash, and to_s each leaf node?
+      def normalize_data(hash)
+        new_hash = {}
+
+        hash.each do |key, value|
+          if value.respond_to?(:to_hash)
+            begin
+              new_hash[key] = normalize_data(value.to_hash)
+            rescue
+              new_hash[key] = LengthLimit.new(value.to_s).to_s
+            end
+          else
+            new_hash[key] = LengthLimit.new(value.to_s).to_s
+          end
+        end
+
+        new_hash
+      end
+
+      ###################
+      # Filtering Params
+      ###################
+
+      # Replaces parameter values with a string / set in config file
+      def filter_params(params)
+        return params unless filtered_params_config
+
+        params.each do |k, v|
+          if filter_key?(k)
+            params[k] = "[FILTERED]"
+          elsif v.respond_to?(:to_hash)
+            filter_params(params[k])
+          end
+        end
+
+        params
+      end
+
+      # Check, if a key should be filtered
+      def filter_key?(key)
+        params_to_filter.any? do |filter|
+          key.to_s == filter.to_s # key.to_s.include?(filter.to_s)
+        end
+      end
+
+      def params_to_filter
+        @params_to_filter ||= filtered_params_config + rails_filtered_params
+      end
+
+      # Accessor for the filtered params config value. Will be removed as we refactor and clean up this code.
+      # TODO: Flip this over to use a new class like filtered exceptions?
+      def filtered_params_config
+        @agent_context.config.value("errors_filtered_params")
+      end
+
+      def rails_filtered_params
+        return [] unless defined?(Rails)
+        Rails.configuration.filter_parameters
+      rescue 
+        []
+      end
+
+      class LengthLimit
+        attr_reader :text
+        attr_reader :char_limit
+
+        def initialize(text, char_limit=100)
+          @text = text
+          @char_limit = char_limit
+        end
+
+        def to_s
+          text[0..char_limit]
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/ignored_exceptions.rb

@@ -0,0 +1,66 @@
+# Encapsulates the management and checking of ignored exceptions. Allows using
+# string matches on the class name, or arbitrary matching with a callback
+module ScoutApm
+  module ErrorService
+    class IgnoredExceptions
+      attr_reader :ignored_exceptions
+      attr_reader :blocks
+
+      def initialize(context, from_config)
+        @context = context
+        @ignored_exceptions = Array(from_config).map{ |e| normalize_as_klass(e) }
+        @blocks = []
+      end
+
+      # Add a single ignored exception by class name
+      def add(klass_or_str)
+        @ignored_exceptions << normalize_as_klass(klass_or_str)
+      end
+
+      # Add a callback block that will be called on every error. If it returns
+      # Signature of blocks:  ->(exception object): truthy or falsy value
+      def add_callback(&block)
+        @blocks << block
+      end
+
+      def ignored?(exception_object)
+        klass = normalize_as_klass(exception_object)
+
+        # Check if we ignored this error by name (typical way to ignore)
+        if ignored_exceptions.any? { |ignored| klass.ancestors.include?(ignored) }
+          return true
+        end
+
+        # For each block, see if it says we should ignore this error
+        blocks.each do |b|
+          if b.call(exception_object)
+            return true
+          end
+        end
+
+        false
+      end
+
+      private
+
+      def normalize_as_klass(klass_or_str)
+        if Module === klass_or_str
+          return klass_or_str
+        end
+
+        if klass_or_str.is_a?(Exception)
+          return klass_or_str.class
+        end
+
+        if String === klass_or_str
+          maybe = ScoutApm::Utils::KlassHelper.lookup(klass_or_str)
+          if Module === maybe
+            return maybe
+          end
+        end
+
+        klass_or_str
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/middleware.rb

@@ -0,0 +1,32 @@
+module ScoutApm
+  module ErrorService
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        begin
+          response = @app.call(env)
+        rescue Exception => exception
+          puts "[Scout Error Service] Caught Exception: #{exception.class.name}"
+
+          context = ScoutApm::Agent.instance.context
+
+          # Bail out early, and reraise if the error is not interesting.
+          if context.ignored_exceptions.ignored?(exception)
+            raise
+          end
+
+          # Capture the error for further processing and shipping
+          context.error_buffer.capture(exception, env)
+
+          # Finally re-raise
+          raise
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/notifier.rb

@@ -0,0 +1,33 @@
+module ScoutApm
+  module ErrorService
+    class Notifier
+      attr_reader :context
+      attr_reader :reporter
+
+      def initialize(context)
+        @context = context
+        @reporter = ScoutApm::Reporter.new(context, :errors)
+      end
+
+      def ship
+        error_records = context.error_buffer.get_and_reset_error_records
+        if error_records.any?
+          payload = ScoutApm::ErrorService::Payload.new(context, error_records)
+          reporter.report(
+            payload.serialize,
+            default_headers.merge("X-Error-Count" => error_records.length.to_s)
+          )
+        end
+      end
+
+      private
+
+      def default_headers
+        {
+          "Content-Type" => "application/json",
+          "Accept" => "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/payload.rb

@@ -0,0 +1,47 @@
+module ScoutApm
+  module ErrorService
+    class Payload
+      attr_reader :context
+      attr_reader :errors
+
+      def initialize(context, errors)
+        @context = context
+        @errors = errors
+      end
+
+      # TODO: Don't use to_json since it isn't supported in Ruby 1.8.7
+      def serialize
+        payload = as_json.to_json
+        context.logger.info(payload)
+        payload
+      end
+
+      def as_json
+        serialized_errors = errors.map do |error_record|
+          serialize_error_record(error_record)
+        end
+
+        {
+          :notifier => "scout_apm_ruby",
+          :environment => context.environment.env,
+          :root => context.environment.root,
+          :problems => serialized_errors,
+        }
+      end
+
+      def serialize_error_record(error_record)
+        {
+          :exception_class => error_record.exception_class,
+          :message => error_record.message,
+          :request_uri => error_record.request_uri,
+          :request_params => error_record.request_params,
+          :request_session => error_record.request_session,
+          :environment => error_record.environment,
+          :trace => error_record.trace,
+          :request_components => error_record.request_components,
+          :context => error_record.context,
+        }
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/periodic_work.rb

@@ -0,0 +1,17 @@
+module ScoutApm
+  module ErrorService
+    class PeriodicWork
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+        @notifier = ScoutApm::ErrorService::Notifier.new(context)
+      end
+
+      # Expected to be called many times over the life of the agent
+      def run
+        @notifier.ship
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/railtie.rb

@@ -0,0 +1,11 @@
+module ScoutApm
+  module ErrorService
+    class Railtie < Rails::Railtie
+      initializer "scoutapm_error_service.middleware" do |app|
+        next if ScoutApm::Agent.instance.config.value("error_service")
+
+        app.config.middleware.insert_after ActionDispatch::DebugExceptions, ScoutApm::ErrorService::Rack
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/sidekiq.rb

@@ -0,0 +1,80 @@
+module ScoutApm
+  module ErrorService
+    class Sidekiq
+      def initialize
+        @context = ScoutApm::Agent.instance.context
+      end
+
+      def install
+        return false unless defined?(::Sidekiq)
+
+        if ::Sidekiq::VERSION < "3"
+          install_sidekiq_with_middleware
+        else
+          install_sidekiq_with_error_handler
+        end
+
+        true
+      end
+
+      def install_sidekiq_with_middleware
+        # old behavior
+        ::Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add ScoutApm::ErrorService::Sidekiq::SidekiqExceptionMiddleware
+          end
+        end
+      end
+
+      def install_sidekiq_with_error_handler
+        ::Sidekiq.configure_server do |config|
+          config.error_handlers << proc { |exception, job_info|
+            context = ScoutApm::Agent.instance.context
+
+            # Bail out early, and reraise if the error is not interesting.
+            if context.ignored_exceptions.ignored?(exception)
+              raise
+            end
+
+            job_class =
+              begin
+                job_class = job_info[:job]["class"]
+                job_class = job_info[:job]["args"][0]["job_class"] if job_class == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+                job_class
+              rescue
+                "UnknownJob"
+              end
+
+            # Capture the error for further processing and shipping
+            context.error_buffer.capture(exception, job_info.merge(:custom_controller => job_class))
+          }
+        end
+      end
+
+      class SidekiqExceptionMiddleware
+        def call(worker, msg, queue)
+          yield
+        rescue => exception
+          context = ScoutApm::Agent.instance.context
+
+          # Bail out early, and reraise if the error is not interesting.
+          if context.ignored_exceptions.ignored?(exception)
+            raise
+          end
+
+          # Capture the error for further processing and shipping
+          context.error_buffer.capture(
+            exception,
+            {
+              :custom_params => msg,
+              :custom_controller => msg["class"]
+            }
+          )
+
+          # Finally, reraise
+          raise exception
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/middleware.rb

@@ -26,7 +26,7 @@ module ScoutApm
       ScoutApm::Agent.instance.start
       @started = ScoutApm::Agent.instance.context.started? && ScoutApm::Agent.instance.background_worker_running?
     rescue => e
-      ScoutApm::Agent.instance.context.logger("Failed to start via Middleware: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+      ScoutApm::Agent.instance.context.logger.info("Failed to start via Middleware: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
     end
   end
 end

data/lib/scout_apm/reporter.rb

@@ -22,6 +22,7 @@ module ScoutApm
       context.logger
     end
 
+    # The fully serialized string payload to be sent
     def report(payload, headers = {})
       hosts = determine_hosts
 
@@ -35,6 +36,7 @@ module ScoutApm
         logger.debug("Original Size: #{original_payload_size} Compressed Size: #{compress_payload_size}")
       end
 
+      logger.info("Posting payload to #{hosts.inspect}")
       post_payload(hosts, payload, headers)
     end
 
@@ -51,6 +53,8 @@ module ScoutApm
         URI.parse("#{host}/apps/deploy.scout?key=#{key}&name=#{encoded_app_name}")
       when :instant_trace
         URI.parse("#{host}/apps/instant_trace.scout?key=#{key}&name=#{encoded_app_name}&instant_key=#{instant_key}")
+      when :errors
+        URI.parse("#{host}/apps/error.scout?key=#{key}&name=#{encoded_app_name}")
       end.tap { |u| logger.debug("Posting to #{u}") }
     end
 
@@ -89,7 +93,7 @@ module ScoutApm
       logger.debug "got response: #{response.inspect}"
       case response
       when Net::HTTPSuccess, Net::HTTPNotModified
-        logger.debug "/#{type} OK"
+        logger.debug "#{type} OK"
       when Net::HTTPBadRequest
         logger.warn "/#{type} FAILED: The Account Key [#{config.value('key')}] is invalid."
       when Net::HTTPUnprocessableEntity
@@ -141,6 +145,8 @@ module ScoutApm
     def determine_hosts
       if [:deploy_hook, :instant_trace].include?(type)
         config.value('direct_host')
+      elsif [:errors].include?(type)
+        config.value('errors_host')
       else
         config.value('host')
       end

data/lib/scout_apm/serializers/payload_serializer_to_json.rb

@@ -45,18 +45,36 @@ module ScoutApm
           "{#{str_parts.join(",")}}"
         end
 
-        ESCAPE_MAPPINGS = {
-          "\b" => '\\b',
-          "\t" => '\\t',
-          "\n" => '\\n',
-          "\f" => '\\f',
-          "\r" => '\\r',
-          '"'  => '\\"',
-          '\\' => '\\\\',
-        }
+        # Ruby 1.8.7 seems to be fundamentally different in how gsub or regexes
+        # work. This is a hack and will be removed as soon as we can drop
+        # support
+        if RUBY_VERSION == "1.8.7"
+          ESCAPE_MAPPINGS = {
+            "\b" => '\\b',
+            "\t" => '\\t',
+            "\n" => '\\n',
+            "\f" => '\\f',
+            "\r" => '\\r',
+            '"'  => '\\"',
+            '\\' => '\\\\',
+          }
+        else
+          ESCAPE_MAPPINGS = {
+            # Stackoverflow answer on gsub matches and backslashes - https://stackoverflow.com/a/4149087/2705125
+            '\\' => '\\\\\\\\',
+            "\b" => '\\b',
+            "\t" => '\\t',
+            "\n" => '\\n',
+            "\f" => '\\f',
+            "\r" => '\\r',
+            '"'  => '\\"',
+          }
+        end
 
         def escape(string)
-          ESCAPE_MAPPINGS.inject(string.to_s) {|s, (bad, good)| s.gsub(bad, good) }
+          ESCAPE_MAPPINGS.inject(string.to_s) {|s, (bad, good)| 
+            s.gsub(bad, good)
+          }
         end
 
         def format_by_type(formatee)

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "2.6.9"
+  VERSION = "2.6.10"
 end

data/test/unit/agent_context_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+
+require "scout_apm/agent_context"
+
+class AgentContextTest < Minitest::Test
+  def test_has_error_service_ignored_exceptions
+    context = ScoutApm::AgentContext.new
+    assert ScoutApm::ErrorService::IgnoredExceptions, context.ignored_exceptions.class
+  end
+
+  def test_has_error_buffer
+    context = ScoutApm::AgentContext.new
+    assert ScoutApm::ErrorService::ErrorBuffer, context.error_buffer.class
+  end
+end

data/test/unit/error_service/error_buffer_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class ErrorBufferTest < Minitest::Test
+  class FakeError < StandardError
+  end
+
+  def test_captures_and_stores_exceptions_and_env
+    eb = ScoutApm::ErrorService::ErrorBuffer.new(context)
+    eb.capture(ex, env)
+  end
+
+  #### Helpers
+
+  def context
+    ScoutApm::AgentContext.new
+  end
+
+  def env
+    {}
+  end
+
+  def ex(msg="Whoops")
+    FakeError.new(msg)
+  end
+end

data/test/unit/error_service/ignored_exceptions_test.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+class IgnoredExceptionsTest < Minitest::Test
+  class FakeError < StandardError
+  end
+
+  class SubclassFakeError < FakeError
+  end
+
+  def test_ignores_with_string_match
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["RuntimeError"])
+    assert ig.ignored?(RuntimeError.new("something went wrong"))
+    assert !ig.ignored?(FakeError.new("something went wrong"))
+  end
+
+  def test_ignores_with_block
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, [])
+    ig.add_callback { |e| e.message == "ignore me" }
+
+    should_ignore = RuntimeError.new("ignore me")
+    should_not_ignore = RuntimeError.new("super legit")
+
+    assert ig.ignored?(should_ignore)
+    assert !ig.ignored?(should_not_ignore)
+  end
+
+  def test_ignores_subclasses
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["IgnoredExceptionsTest::FakeError"])
+    assert ig.ignored?(SubclassFakeError.new("Subclass"))
+  end
+
+  # Check that a bad exception in the list doesn't stop the whole thing from working
+  def test_does_not_consider_unknown_errors
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["ThisDoesNotExist", "IgnoredExceptionsTest::FakeError"])
+    assert ig.ignored?(FakeError.new("ignore this one"))
+  end
+
+  def test_add_module
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, [])
+    ig.add(IgnoredExceptionsTest::FakeError)
+    assert ig.ignored?(FakeError.new("ignore this one"))
+  end
+
+  #### Helpers
+
+  def context
+    ScoutApm::AgentContext.new
+  end
+end

data/test/unit/serializers/payload_serializer_test.rb

@@ -108,4 +108,40 @@ class PayloadSerializerTest < Minitest::Test
     json = { "foo" => "\bbar\nbaz\r" }
     assert_equal json, JSON.parse(ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(json))
   end
+
+  def test_escapes_escaped_quotes
+    # Some escapes haven't ever worked on 1.8.7, and is not the issue I'm
+    # fixing now. Remove this when we drop support for ancient ruby
+    skip if RUBY_VERSION == "1.8.7"
+
+    json = {"foo" => %q|`additional_details` = '{\"amount\":1}'|}
+    result = ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(json)
+    assert_equal json, JSON.parse(result)
+  end
+
+  def test_escapes_various_special_characters
+    # Some escapes haven't ever worked on 1.8.7, and is not the issue I'm
+    # fixing now. Remove this when we drop support for ancient ruby
+    skip if RUBY_VERSION == "1.8.7"
+
+    json = {"foo" => [
+      %Q|\fbar|,
+      %Q|\rbar|,
+      %Q|\nbar|,
+      %Q|\tbar|,
+      %Q|"bar|,
+      %Q|'bar|,
+      %Q|{bar|,
+      %Q|}bar|,
+      %Q|\\bar|,
+      if RUBY_VERSION == '1.8.7'
+        ""
+      else
+        %Q|\\\nbar|
+      end,
+    ]}
+
+    result = ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(json)
+    assert_equal json, JSON.parse(result)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 2.6.9
+  version: 2.6.10
 platform: ruby
 authors:
 - Derek Haynes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-17 00:00:00.000000000 Z
+date: 2020-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -267,6 +267,17 @@ files:
 - lib/scout_apm/debug.rb
 - lib/scout_apm/detailed_trace.rb
 - lib/scout_apm/environment.rb
+- lib/scout_apm/error.rb
+- lib/scout_apm/error_service.rb
+- lib/scout_apm/error_service/error_buffer.rb
+- lib/scout_apm/error_service/error_record.rb
+- lib/scout_apm/error_service/ignored_exceptions.rb
+- lib/scout_apm/error_service/middleware.rb
+- lib/scout_apm/error_service/notifier.rb
+- lib/scout_apm/error_service/payload.rb
+- lib/scout_apm/error_service/periodic_work.rb
+- lib/scout_apm/error_service/railtie.rb
+- lib/scout_apm/error_service/sidekiq.rb
 - lib/scout_apm/extensions/config.rb
 - lib/scout_apm/extensions/transaction_callback_payload.rb
 - lib/scout_apm/fake_store.rb
@@ -390,6 +401,7 @@ files:
 - test/data/config_test_1.yml
 - test/test_helper.rb
 - test/tmp/README.md
+- test/unit/agent_context_test.rb
 - test/unit/agent_test.rb
 - test/unit/auto_instrument/assignments-instrumented.rb
 - test/unit/auto_instrument/assignments.rb
@@ -405,6 +417,8 @@ files:
 - test/unit/db_query_metric_set_test.rb
 - test/unit/db_query_metric_stats_test.rb
 - test/unit/environment_test.rb
+- test/unit/error_service/error_buffer_test.rb
+- test/unit/error_service/ignored_exceptions_test.rb
 - test/unit/extensions/periodic_callbacks_test.rb
 - test/unit/extensions/transaction_callbacks_test.rb
 - test/unit/fake_store_test.rb
@@ -460,61 +474,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Ruby application performance monitoring
-test_files:
-- test/data/config_test_1.yml
-- test/test_helper.rb
-- test/tmp/README.md
-- test/unit/agent_test.rb
-- test/unit/auto_instrument/assignments-instrumented.rb
-- test/unit/auto_instrument/assignments.rb
-- test/unit/auto_instrument/controller-ast.txt
-- test/unit/auto_instrument/controller-instrumented.rb
-- test/unit/auto_instrument/controller.rb
-- test/unit/auto_instrument/rescue_from-instrumented.rb
-- test/unit/auto_instrument/rescue_from.rb
-- test/unit/auto_instrument_test.rb
-- test/unit/background_job_integrations/sidekiq_test.rb
-- test/unit/config_test.rb
-- test/unit/context_test.rb
-- test/unit/db_query_metric_set_test.rb
-- test/unit/db_query_metric_stats_test.rb
-- test/unit/environment_test.rb
-- test/unit/extensions/periodic_callbacks_test.rb
-- test/unit/extensions/transaction_callbacks_test.rb
-- test/unit/fake_store_test.rb
-- test/unit/git_revision_test.rb
-- test/unit/histogram_test.rb
-- test/unit/ignored_uris_test.rb
-- test/unit/instruments/active_record_test.rb
-- test/unit/instruments/net_http_test.rb
-- test/unit/instruments/percentile_sampler_test.rb
-- test/unit/layaway_test.rb
-- test/unit/layer_children_set_test.rb
-- test/unit/layer_converters/depth_first_walker_test.rb
-- test/unit/layer_converters/metric_converter_test.rb
-- test/unit/layer_converters/stubs.rb
-- test/unit/limited_layer_test.rb
-- test/unit/logger_test.rb
-- test/unit/metric_set_test.rb
-- test/unit/remote/test_message.rb
-- test/unit/remote/test_router.rb
-- test/unit/remote/test_server.rb
-- test/unit/request_histograms_test.rb
-- test/unit/scored_item_set_test.rb
-- test/unit/serializers/payload_serializer_test.rb
-- test/unit/slow_job_policy_test.rb
-- test/unit/slow_request_policy_test.rb
-- test/unit/sql_sanitizer_test.rb
-- test/unit/store_test.rb
-- test/unit/tracer_test.rb
-- test/unit/tracked_request_test.rb
-- test/unit/transaction_test.rb
-- test/unit/transaction_time_consumed_test.rb
-- test/unit/utils/active_record_metric_name_test.rb
-- test/unit/utils/backtrace_parser_test.rb
-- test/unit/utils/numbers_test.rb
-- test/unit/utils/scm.rb
+test_files: []