scout_apm 2.6.6 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73af2b28e0b054233c1ccd48122741d7b8e27adf9c61ee93fea520f7e3a6b3c7
-  data.tar.gz: 544c20bf5c56478269232f19a792dcbc00c125befb6e5e7b406be04dc954944e
+  metadata.gz: ffcf571075c7f443ebe029e8f07c726cc5cb6c12e156d47e2565c576ac671316
+  data.tar.gz: 684f8ed4ba52d2e5819ea319288333a83f8b5481491ae879be2e8031cdd5d6ee
 SHA512:
-  metadata.gz: c8558cd998a6c54ca7cd3c3174ba96c28230b0041a49e2d494460116a6f9065ba28f998ce8a74b546f69a8f1d5ec5dd81b9be29e27f4a874f51e1352f02798f0
-  data.tar.gz: 18f7152a257b7ff61cb0c4953542527a2af25220d726ac26ade9242421f817afc83ce18fa28ea018188215717cedb25336ba79a61572cb706f99f16278be3545
+  metadata.gz: a4d90917dc02469213092848211fe779f44ec09e7db4829aaaa737ca15cf1811137dc2a4ae00adaa76cc2be92916b0467f164f79a76fac501c7a4827ba5d6f7d
+  data.tar.gz: 776d064902d998cc69330e470fbc9bfb368ae401d8e8a341310e4dc2a9070a256a2e57370505ee3475761d26145e4efced633963243527e39b95ab584bf48b2a

data/.rubocop.yml

@@ -10,7 +10,3 @@ AllCops:
 Metrics/LineLength:
   Enabled: false
   Max: 100
-
-Style/HashSyntax:
-  Enabled: true
-  EnforcedStyle: hash_rockets

data/.travis.yml

@@ -4,12 +4,6 @@ cache: bundler
 
 matrix:
   include:
-    - rvm: "1.8.7"
-      gemfile: gems/rails3.gemfile
-    - rvm: "1.9.3"
-      gemfile: gems/rails3.gemfile
-    - rvm: 2.0
-      gemfile: gems/rails3.gemfile
     - rvm: 2.1
       gemfile: gems/rails3.gemfile
     - rvm: 2.2

data/CHANGELOG.markdown

@@ -1,3 +1,33 @@
+# 4.0.0
+
+* Require Ruby >= 2.1 (#270)
+* ErrorService reporting. Enable with `errors_enabled` config setting. (#347)
+* Modular SlowRequestPolicy (#364)
+* Fix deprecation warnings (#354)
+
+# 2.6.10
+
+* Fix an edge case in JSON serialization (#360)
+
+# 2.6.9
+
+* Add `ssl_cert_file` config option (#352)
+* Improve sanitization of Postgres UPDATE SQL (#351)
+* Allow custom URL sanitization (#341)
+
+# 2.6.8
+
+* Lock rake version for 1.8.7 to older version (#329)
+* Delete unneeded .DS_Store file that snuck in (#334)
+* Fix typo in "queue_time_ms"
+* Fix Rails 6 deprecation warning at boot time (#337)
+* Fix partial naming on Rails 6.0 (#339)
+* Support Sidekiq 6.1 instrumentation (#340)
+
+# 2.6.7
+
+* Remove accidental call to `as_json`
+
 # 2.6.6
 
 * Add basic support for parsing Microsoft SQLServer queries (#317)

data/Gemfile

@@ -3,11 +3,4 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in scout_apm.gemspec
 gemspec
 
-# Pin development dependencies more conservatively for Ruby 1.8.7
-if RUBY_VERSION <= "1.8.7"
-  gem "activesupport", "~> 3.2"
-  gem "i18n", "~> 0.6.11"
-  gem "pry", "~> 0.9.12"
-  gem "rake", "~> 10.5"
-  gem "minitest", "~> 5.11.3"
-end
+gem "rake", ">= 12.3.3"

data/lib/scout_apm.rb

@@ -144,8 +144,13 @@ require 'scout_apm/slow_transaction'
 require 'scout_apm/slow_job_record'
 require 'scout_apm/detailed_trace'
 require 'scout_apm/scored_item_set'
+
 require 'scout_apm/slow_request_policy'
-require 'scout_apm/slow_job_policy'
+require 'scout_apm/slow_policy/age_policy'
+require 'scout_apm/slow_policy/speed_policy'
+require 'scout_apm/slow_policy/percent_policy'
+require 'scout_apm/slow_policy/percentile_policy'
+
 require 'scout_apm/job_record'
 require 'scout_apm/request_histograms'
 require 'scout_apm/transaction_time_consumed'
@@ -186,6 +191,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 +220,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

@@ -96,11 +96,11 @@ module ScoutApm
     end
 
     def slow_request_policy
-      @slow_request_policy ||= ScoutApm::SlowRequestPolicy.new(self)
+      @slow_request_policy ||= ScoutApm::SlowRequestPolicy.new(self).tap{|p| p.add_default_policies }
     end
 
     def slow_job_policy
-      @slow_job_policy ||= ScoutApm::SlowJobPolicy.new(self)
+      @slow_job_policy ||= ScoutApm::SlowRequestPolicy.new(self).tap{|p| p.add_default_policies }
     end
 
     # Maintains a Histogram of insignificant/significant autoinstrument layers.
@@ -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/background_job_integrations/sidekiq.rb

@@ -40,10 +40,10 @@ module ScoutApm
         require 'sidekiq/processor' # sidekiq v4 has not loaded this file by this point
 
         ::Sidekiq::Processor.class_eval do
-          def initialize_with_scout(boss)
+          def initialize_with_scout(*args)
             agent = ::ScoutApm::Agent.instance
             agent.start
-            initialize_without_scout(boss)
+            initialize_without_scout(*args)
           end
 
           alias_method :initialize_without_scout, :initialize

data/lib/scout_apm/config.rb

@@ -75,11 +75,18 @@ module ScoutApm
         'revision_sha',
         'scm_subdirectory',
         'start_resque_server_instrument',
+        'ssl_cert_file',
         'uri_reporting',
         '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',
     ]
 
     ################################################################################
@@ -175,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,
     }
 
 
@@ -284,7 +294,12 @@ module ScoutApm
         'collect_remote_ip' => true,
         'timeline_traces' => true,
         'auto_instruments' => false,
-        'auto_instruments_ignore' => []
+        'auto_instruments_ignore' => [],
+        '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/detailed_trace.rb

@@ -200,8 +200,9 @@ class DetailedTraceTags
     @tags = hash
   end
 
+  # @tags is already a hash, so no conversion needed
   def as_json(*)
-    @tags.as_json
+    @tags
   end
 end
 

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