scout_apm 2.6.5 → 2.6.10

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/extensions/transaction_callback_payload.rb

@@ -26,7 +26,7 @@ module ScoutApm
       # The time in queue of the transaction in ms. If not present, +nil+ is returned as this is unknown.
       def queue_time_ms
         # Controller logic
-        if converter_results[:queue_time] && converter_results[:queue].any?
+        if converter_results[:queue_time] && converter_results[:queue_time].any?
           converter_results[:queue_time].values.first.total_call_time*1000 # ms
         # Job logic
         elsif converter_results[:job]

data/lib/scout_apm/framework_integrations/rails_3_or_4.rb

@@ -48,6 +48,7 @@ module ScoutApm
           when "sqlite"     then :sqlite
           when "mysql"      then :mysql
           when "mysql2"     then :mysql
+          when "sqlserver"  then :sqlserver
           else default
           end
         else

data/lib/scout_apm/instruments/action_controller_rails_3_rails4.rb

@@ -17,46 +17,73 @@ module ScoutApm
         @installed
       end
 
+      def installed!
+        @installed = true
+      end
+
       def install
-        # We previously instrumented ActionController::Metal, which missed
-        # before and after filter timing. Instrumenting Base includes those
-        # filters, at the expense of missing out on controllers that don't use
-        # the full Rails stack.
-        if defined?(::ActionController)
-          @installed = true
+        if !defined?(::ActiveSupport)
+          return
+        end
+
+        # The block below runs with `self` equal to the ActionController::Base or ::API module, not this class we're in now. By saving an instance of ourselves into the `this` variable, we can continue accessing what we need.
+        this = self
 
+        ActiveSupport.on_load(:action_controller) do
+          if this.installed?
+            this.logger.info("Skipping ActionController - Already Ran")
+            next
+          else
+            this.logger.info("Instrumenting ActionController (on_load)")
+            this.installed!
+          end
+
+          # We previously instrumented ActionController::Metal, which missed
+          # before and after filter timing. Instrumenting Base includes those
+          # filters, at the expense of missing out on controllers that don't use
+          # the full Rails stack.
           if defined?(::ActionController::Base)
-            logger.info "Instrumenting ActionController::Base"
+            this.logger.info "Instrumenting ActionController::Base"
             ::ActionController::Base.class_eval do
-              # include ScoutApm::Tracer
               include ScoutApm::Instruments::ActionControllerBaseInstruments
             end
           end
 
           if defined?(::ActionController::Metal)
-            logger.info "Instrumenting ActionController::Metal"
+            this.logger.info "Instrumenting ActionController::Metal"
             ::ActionController::Metal.class_eval do
               include ScoutApm::Instruments::ActionControllerMetalInstruments
             end
           end
 
           if defined?(::ActionController::API)
-            logger.info "Instrumenting ActionController::Api"
+            this.logger.info "Instrumenting ActionController::Api"
             ::ActionController::API.class_eval do
               include ScoutApm::Instruments::ActionControllerAPIInstruments
             end
           end
         end
 
-        # Returns a new anonymous module each time it is called. So
-        # we can insert this multiple times into the ancestors
-        # stack. Otherwise it only exists the first time you include it
-        # (under Metal, instead of under API) and we miss instrumenting
-        # before_action callbacks
+        ScoutApm::Agent.instance.context.logger.info("Instrumenting ActionController (hook installed)")
       end
 
+      # Returns a new anonymous module each time it is called. So
+      # we can insert this multiple times into the ancestors
+      # stack. Otherwise it only exists the first time you include it
+      # (under Metal, instead of under API) and we miss instrumenting
+      # before_action callbacks
       def self.build_instrument_module
         Module.new do
+          # Determine the URI of this request to capture. Overridable by users in their controller.
+          def scout_transaction_uri(config=ScoutApm::Agent.instance.context.config)
+            case config.value("uri_reporting")
+            when 'path'
+              request.path # strips off the query string for more security
+            else # default handles filtered params
+              request.filtered_path
+            end
+          end
+
           def process_action(*args)
             req = ScoutApm::RequestManager.lookup
             current_layer = req.current_layer
@@ -72,7 +99,11 @@ module ScoutApm
               # Don't start a new layer if ActionController::API or ActionController::Base handled it already.
               super
             else
-              req.annotate_request(:uri => ScoutApm::Instruments::ActionControllerRails3Rails4.scout_transaction_uri(request))
+              begin
+                uri = scout_transaction_uri
+                req.annotate_request(:uri => uri)
+              rescue
+              end
 
               # IP Spoofing Protection can throw an exception, just move on w/o remote ip
               if agent_context.config.value('collect_remote_ip')
@@ -95,16 +126,6 @@ module ScoutApm
         end
       end
 
-      # Given an +ActionDispatch::Request+, formats the uri based on config settings.
-      # XXX: Don't lookup context like this - find a way to pass it through
-      def self.scout_transaction_uri(request, config=ScoutApm::Agent.instance.context.config)
-        case config.value("uri_reporting")
-        when 'path'
-          request.path # strips off the query string for more security
-        else # default handles filtered params
-          request.filtered_path
-        end
-      end
     end
 
     module ActionControllerMetalInstruments

data/lib/scout_apm/instruments/action_view.rb

@@ -75,13 +75,18 @@ module ScoutApm
       end
 
       module ActionViewPartialRendererInstruments
+        # In Rails 6, the signature changed to pass the view & template args directly, as opposed to through the instance var
+        # New signature is: def render_partial(view, template)
         def render_partial(*args)
           req = ScoutApm::RequestManager.lookup
 
-          template_name = @template.virtual_path rescue "Unknown Partial"
+          maybe_template = args[1]
+
+          template_name = @template.virtual_path rescue nil        # Works on Rails 3.2 -> end of Rails 5 series
+          template_name ||= maybe_template.virtual_path rescue nil # Works on Rails 6 -> 6.0.3
           template_name ||= "Unknown Partial"
-          layer_name = template_name + "/Rendering"
 
+          layer_name = template_name + "/Rendering"
           layer = ScoutApm::Layer.new("View", layer_name)
           layer.subscopable!