scout_apm 2.1.32 → 2.2.0.pre0

data/lib/scout_apm/instruments/action_controller_rails_2.rb

@@ -48,7 +48,8 @@ module ScoutApm
       # specific controller actions.
       def perform_action_with_scout_instruments(*args, &block)
         req = ScoutApm::RequestManager.lookup
-        req.annotate_request(:uri => request.path) # for security by-default, we don't use request.fullpath which could reveal filtered params.
+        path = ScoutApm::Agent.instance.config.value("uri_reporting") == 'path' ? request.path : request.fullpath
+        req.annotate_request(:uri => path)
         req.context.add_user(:ip => request.remote_ip)
         req.set_headers(request.headers)
         req.start_layer( ScoutApm::Layer.new("Controller", "#{controller_path}/#{action_name}") )

data/lib/scout_apm/instruments/action_controller_rails_3_rails4.rb

@@ -20,112 +20,81 @@ module ScoutApm
         # 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)
-          if defined?(::ActionController::Base)
-            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Base"
-            ::ActionController::Base.class_eval do
-              # include ScoutApm::Tracer
-              include ScoutApm::Instruments::ActionControllerBaseInstruments
-            end
-          end
-
-          if defined?(::ActionController::Metal)
-            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Metal"
-            ::ActionController::Metal.class_eval do
-              include ScoutApm::Instruments::ActionControllerMetalInstruments
-            end
-          end
-
-          if defined?(::ActionController::API)
-            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Api"
-            ::ActionController::API.class_eval do
-              include ScoutApm::Instruments::ActionControllerAPIInstruments
-            end
+        if defined?(::ActionController) && defined?(::ActionController::Base)
+          ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Base"
+          ::ActionController::Base.class_eval do
+            # include ScoutApm::Tracer
+            include ScoutApm::Instruments::ActionControllerRails3Rails4Instruments
           end
+          ScoutApm::Agent.instance.logger.info "Installing ScoutProf profiling" if ScoutApm::Agent.instance.config.value('profile')
         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
-      end
+        if defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
+          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::PartialRenderer"
+          ::ActionView::PartialRenderer.class_eval do
+            include ScoutApm::Tracer
 
-      def self.build_instrument_module
-        Module.new do
-          def process_action(*args)
-            req = ScoutApm::RequestManager.lookup
-            current_layer = req.current_layer
-
-            # Check if this this request is to be reported instantly
-            if instant_key = request.cookies['scoutapminstant']
-              Agent.instance.logger.info "Instant trace request with key=#{instant_key} for path=#{path}"
-              req.instant_key = instant_key
-            end
-
-            if current_layer && current_layer.type == "Controller"
-              # 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))
-
-              # IP Spoofing Protection can throw an exception, just move on w/o remote ip
-              req.context.add_user(:ip => request.remote_ip) rescue nil
-              req.set_headers(request.headers)
-
-              req.web!
-
-              resolved_name = scout_action_name(*args)
-              req.start_layer( ScoutApm::Layer.new("Controller", "#{controller_path}/#{resolved_name}") )
-              begin
-                super
-              rescue
-                req.error!
-                raise
-              ensure
-                req.stop_layer
-              end
-            end
+            instrument_method :render_partial,
+              :type => "View",
+              :name => '#{@template.virtual_path rescue "Unknown Partial"}/Rendering',
+              :scope => true
+
+            instrument_method :collection_with_template,
+              :type => "View",
+              :name => '#{@template.virtual_path rescue "Unknown Collection"}/Rendering',
+              :scope => true
           end
-        end
-      end
 
-      # Given an +ActionDispatch::Request+, formats the uri based on config settings.
-      def self.scout_transaction_uri(request)
-        case ScoutApm::Agent.instance.config.value("uri_reporting")
-        when 'path'
-          request.path # strips off the query string for more security
-        else # default handles filtered params
-          request.filtered_path
+          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::TemplateRenderer"
+          ::ActionView::TemplateRenderer.class_eval do
+            include ScoutApm::Tracer
+            instrument_method :render_template,
+              :type => "View",
+              :name => '#{args[0].virtual_path rescue "Unknown"}/Rendering',
+              :scope => true
+          end
         end
       end
     end
 
-    module ActionControllerMetalInstruments
-      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
+    module ActionControllerRails3Rails4Instruments
+      def process_action(*args)
+        req = ScoutApm::RequestManager.lookup
+        path = ScoutApm::Agent.instance.config.value("uri_reporting") == 'path' ? request.path : request.fullpath
+        req.annotate_request(:uri => path)
+
+        # IP Spoofing Protection can throw an exception, just move on w/o remote ip
+        req.context.add_user(:ip => request.remote_ip) rescue nil
 
-      def scout_action_name(*args)
-        action_name = args[0]
-      end
-    end
+        req.set_headers(request.headers)
 
-    # Empty, noop module to provide compatibility w/ previous manual instrumentation
-    module ActionControllerRails3Rails4Instruments
-    end
+        # Check if this this request is to be reported instantly
+        if instant_key = request.cookies['scoutapminstant']
+          Agent.instance.logger.info "Instant trace request with key=#{instant_key} for path=#{path}"
+          req.instant_key = instant_key
+        end
 
-    module ActionControllerBaseInstruments
-      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
+        req.web!
 
-      def scout_action_name(*args)
-        action_name
-      end
-    end
+        layer = ScoutApm::Layer.new("Controller", "#{controller_path}/#{action_name}")
 
-    module ActionControllerAPIInstruments
-      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
+        if ScoutApm::Agent.instance.config.value('profile')
+          # Capture ScoutProf if we can
+          req.enable_profiled_thread!
+          layer.set_root_class(self.class)
+          layer.traced!
+        end
 
-      def scout_action_name(*args)
-        action_name
+        # Start the layer, then execute the user's code
+        req.start_layer(layer)
+        begin
+          super
+        rescue
+          req.error!
+          raise
+        ensure
+          req.stop_layer
+        end
       end
     end
   end

data/lib/scout_apm/instruments/active_record.rb

@@ -62,10 +62,8 @@ module ScoutApm
             layer = req.current_layer
             if layer && layer.type == "ActiveRecord"
               layer.annotate_layer(payload)
-            elsif layer
-              ScoutApm::Agent.instance.logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
             else
-              # noop, no layer at all. We're probably ignoring this req.
+              ScoutApm::Agent.instance.logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
             end
           end
         end
@@ -122,7 +120,7 @@ module ScoutApm
             current_layer.desc = desc
           end
 
-          log_without_scout_instruments(*args, &block)
+          log_without_scout_instruments(sql, name, &block)
 
         # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
         else
@@ -130,7 +128,7 @@ module ScoutApm
           layer.desc = desc
           req.start_layer(layer)
           begin
-            log_without_scout_instruments(*args, &block)
+            log_without_scout_instruments(sql, name, &block)
           ensure
             req.stop_layer
           end
@@ -175,7 +173,7 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          find_by_sql_without_scout_instruments(*args, &block)
+          find_by_sql_without_scout_instruments(*args)
         ensure
           req.acknowledge_children!
           req.stop_layer
@@ -201,7 +199,7 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          find_with_associations_without_scout_instruments(*args, &block)
+          find_with_associations_without_scout_instruments(*args)
         ensure
           req.acknowledge_children!
           req.stop_layer

data/lib/scout_apm/instruments/delayed_job.rb

@@ -0,0 +1,57 @@
+module ScoutApm
+  module Instruments
+    class DelayedJob
+      attr_reader :logger
+
+      def initialize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+        if defined?(::Delayed::Worker)
+          ::Delayed::Worker.class_eval do
+            include ScoutApm::Tracer
+            include ScoutApm::Instruments::DelayedJobInstruments
+            alias run_without_scout_instruments run
+            alias run run_with_scout_instruments
+          end
+        end
+      end
+    end
+
+    module DelayedJobInstruments
+      def run_with_scout_instruments(job)
+        scout_method_name = method_from_handler(job.handler)
+        queue = job.queue
+        latency = (Time.now.to_f - job.created_at.to_f) * 1000
+
+        ScoutApm::Agent.instance.store.track_one!("Queue", queue, 0, {:extra_metrics => {:latency => latency}})
+        req = ScoutApm::RequestManager.lookup
+        req.job!
+        req.start_layer( ScoutApm::Layer.new("Job", scout_method_name) )
+
+        begin
+          run_without_scout_instruments(job)
+        rescue
+          req.error!
+          raise
+        ensure
+          req.stop_layer
+        end
+      end
+
+      def method_from_handler(handler)
+        job_handler = YAML.load(handler)
+        klass = job_handler.object.name
+        method = job_handler.method_name
+        "#{klass}##{method}"
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/grape.rb

@@ -29,10 +29,9 @@ module ScoutApm
     end
 
     module GrapeEndpointInstruments
-      def run_with_scout_instruments(*args)
-        request = ::Grape::Request.new(env || args.first)
+      def run_with_scout_instruments
+        request = ::Grape::Request.new(env)
         req = ScoutApm::RequestManager.lookup
-
         path = ScoutApm::Agent.instance.config.value("uri_reporting") == 'path' ? request.path : request.fullpath
         req.annotate_request(:uri => path)
 
@@ -56,7 +55,7 @@ module ScoutApm
 
         req.start_layer( ScoutApm::Layer.new("Controller", name) )
         begin
-          run_without_scout_instruments(*args)
+          run_without_scout_instruments
         rescue
           req.error!
           raise

data/lib/scout_apm/instruments/middleware_detailed.rb

@@ -1,11 +1,13 @@
 # Inserts a new middleware between each actual middleware in the application,
 # so as to trace the time for each one.
 #
-# Currently disabled by default due to the overhead of this approach (~10-15ms
-# per request in practice).  Instead, middleware as a whole are instrumented
-# via the MiddlewareSummary class.
+# Currently disabled due to the overhead of this approach (~10-15ms per request
+# in practice).  Instead, middleware as a whole are instrumented via the
+# MiddlewareSummary class.
 #
-# Turn this on with the configuration setting `detailed_middleware` set to true
+# There will likely be a configuration flag to turn this on in favor of the
+# summary tracing in a future version of the agent, but this is not yet
+# implemented.
 module ScoutApm
   module Instruments
     class MiddlewareDetailed

data/lib/scout_apm/instruments/middleware_summary.rb

@@ -23,15 +23,7 @@ module ScoutApm
           ActionDispatch::MiddlewareStack.class_eval do
             def build_with_scout_instruments(app = nil, &block)
               mw_stack = build_without_scout_instruments(app) { block.call if block }
-              if app == mw_stack
-                # Return the raw middleware stack if it equaled app. No
-                # middlewares were created, so nothing to wrap & test.
-                #
-                # Avoids instrumentation of something that doesn't exist
-                mw_stack
-              else
-                MiddlewareSummaryWrapper.new(mw_stack)
-              end
+              MiddlewareSummaryWrapper.new(mw_stack)
             end
 
             alias_method :build_without_scout_instruments, :build
@@ -53,36 +45,6 @@ module ScoutApm
         ensure
           req.stop_layer
         end
-
-        # Some code (found in resque_web initially) attempts to call methods
-        # directly on `MyApplication.app`, which is the middleware stack.
-        # If it hits our middleware instead of the object at the root of the
-        # app that it expected, then a method it expects will not be there, and an
-        # error thrown.
-        #
-        # Specifically, resque_web assumes `ResqueWeb::Engine.app.url_helpers`
-        # is a method call on rails router for its own Engine, when in fact,
-        # we've added a middleware before it.
-        #
-        # So method_missing just proxies anything to the nested @app object
-        #
-        # While method_missing is not very performant, this is only here to
-        # handle edge-cases in other code, and should not be regularly called
-        def method_missing(sym, *arguments, &block)
-          if @app.respond_to?(sym)
-            @app.send(sym, *arguments, &block)
-          else
-            super
-          end
-        end
-
-        def respond_to?(sym, include_private = false)
-          if @app.respond_to?(sym, include_private)
-            true
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/scout_apm/instruments/mongoid.rb

@@ -32,8 +32,8 @@ module ScoutApm
           ### See moped instrument for Moped driven deploys
 
           ### 5.x Mongoid
-          if (mongoid_v5? || mongoid_v6?) && defined?(::Mongoid::Contextual::Mongo)
-            ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 5.x/6.x"
+          if mongoid_v5? && defined?(::Mongoid::Contextual::Mongo)
+            ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 5.x"
             # All the public methods from Mongoid::Contextual::Mongo.
             # TODO: Geo and MapReduce support (?). They are in other Contextual::* classes
             methods = [
@@ -50,24 +50,11 @@ module ScoutApm
                 with_scout_instruments = %Q[
                 def #{method}_with_scout_instruments(*args, &block)
 
-
                   req = ScoutApm::RequestManager.lookup
                   *db, collection = view.collection.namespace.split(".")
 
                   name = collection + "/#{method}"
-
-                  # Between Mongo gem version 2.1 and 2.3, this method name was
-                  # changed. Accomodate both.  If for some reason neither is
-                  # there, try to continue with an empty "filter" hash.
-                  raw_filter = if view.respond_to?(:selector)
-                    view.selector
-                  elsif view.respond_to?(:filter)
-                    view.filter
-                  else
-                    {}
-                  end
-
-                  filter = ScoutApm::Instruments::Mongoid.anonymize_filter(raw_filter)
+                  filter = ScoutApm::Instruments::Mongoid.anonymize_filter(view.filter)
 
                   layer = ScoutApm::Layer.new("MongoDB", name)
                   layer.desc = filter.inspect
@@ -99,14 +86,6 @@ module ScoutApm
         end
       end
 
-      def mongoid_v6?
-        if defined?(::Mongoid::VERSION)
-          ::Mongoid::VERSION =~ /\A6/
-        else
-          false
-        end
-      end
-
 
       # Example of what a filter looks like: => {"founded"=>{"$gte"=>"1980-1-1"}, "name"=>{"$in"=>["Tool", "Deftones", "Melvins"]}}
       # Approach: find every leaf-node, clear it. inspect the whole thing when done.

data/lib/scout_apm/instruments/net_http.rb

@@ -22,17 +22,12 @@ module ScoutApm
             include ScoutApm::Tracer
 
             def request_with_scout_instruments(*args,&block)
-              self.class.instrument("HTTP", "request", :desc => request_scout_description(args.first)) do
+              url = (@address + args.first.path.split('?').first)[0..99]
+              self.class.instrument("HTTP", "request", :desc => url) do
                 request_without_scout_instruments(*args, &block)
               end
             end
 
-            def request_scout_description(req)
-              path = req.path
-              path = path.path if path.respond_to?(:path)
-              (@address + path.split('?').first)[0..99]
-            end
-
             alias request_without_scout_instruments request
             alias request request_with_scout_instruments
           end