scout_apm 2.2.0.pre3 → 2.3.0.pre

data/lib/scout_apm/instruments/action_controller_rails_3_rails4.rb

@@ -20,84 +20,78 @@ 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) && defined?(::ActionController::Base)
-          ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Base"
-          ::ActionController::Base.class_eval do
-            # include ScoutApm::Tracer
-            include ScoutApm::Instruments::ActionControllerRails3Rails4Instruments
+        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
-          ScoutApm::Agent.instance.logger.info "Installing ScoutProf profiling" if ScoutApm::Agent.instance.config.value('profile')
-        end
-
-        if defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
-          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::PartialRenderer"
-          ::ActionView::PartialRenderer.class_eval do
-            include ScoutApm::Tracer
 
-            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
+          if defined?(::ActionController::Metal)
+            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Metal"
+            ::ActionController::Metal.class_eval do
+              include ScoutApm::Instruments::ActionControllerMetalInstruments
+            end
           end
 
-          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
+          if defined?(::ActionController::API)
+            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Api"
+            ::ActionController::API.class_eval do
+              include ScoutApm::Instruments::ActionControllerAPIInstruments
+            end
           end
         end
-      end
-    end
-
-    module ActionControllerRails3Rails4Instruments
-      def process_action(*args)
-        req = ScoutApm::RequestManager.lookup
-        req.annotate_request(:uri => 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)
-
-        # 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
-
-        req.web!
 
-        layer = ScoutApm::Layer.new("Controller", "#{controller_path}/#{action_name}")
-
-        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
+        # 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
 
-        # Start the layer, then execute the user's code
-        req.start_layer(layer)
-        begin
-          super
-        rescue
-          req.error!
-          raise
-        ensure
-          req.stop_layer
+      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
+          end
         end
-      end # process_action
+      end
 
       # Given an +ActionDispatch::Request+, formats the uri based on config settings.
-      def scout_transaction_uri(request)
+      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
@@ -105,8 +99,35 @@ module ScoutApm
           request.filtered_path
         end
       end
+    end
+
+    module ActionControllerMetalInstruments
+      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
+
+      def scout_action_name(*args)
+        action_name = args[0]
+      end
+    end
+
+    # Empty, noop module to provide compatibility w/ previous manual instrumentation
+    module ActionControllerRails3Rails4Instruments
+    end
+
+    module ActionControllerBaseInstruments
+      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
+
+      def scout_action_name(*args)
+        action_name
+      end
+    end
+
+    module ActionControllerAPIInstruments
+      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
 
-    end # ActionControllerRails3Rails4Instruments
+      def scout_action_name(*args)
+        action_name
+      end
+    end
   end
 end
 

data/lib/scout_apm/instruments/action_view.rb

@@ -0,0 +1,49 @@
+module ScoutApm
+  module Instruments
+    # instrumentation for Rails 3 and Rails 4 is the same.
+    class ActionView
+      attr_reader :logger
+
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+
+        if defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
+          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::PartialRenderer"
+          ::ActionView::PartialRenderer.class_eval do
+            include ScoutApm::Tracer
+
+            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
+
+          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
+  end
+end
+
+

data/lib/scout_apm/instruments/active_record.rb

@@ -42,6 +42,18 @@ module ScoutApm
           end
         end
 
+        if Utils::KlassHelper.defined?("ActiveRecord::Base")
+          ::ActiveRecord::Base.class_eval do
+            include ::ScoutApm::Instruments::ActiveRecordUpdateInstruments
+          end
+        end
+
+        if Utils::KlassHelper.defined?("ActiveRecord::Relation")
+          ::ActiveRecord::Relation.class_eval do
+            include ::ScoutApm::Instruments::ActiveRecordRelationInstruments
+          end
+        end
+
         if Utils::KlassHelper.defined?("ActiveRecord::Querying")
           ::ActiveRecord::Querying.module_eval do
             include ::ScoutApm::Tracer
@@ -62,8 +74,10 @@ module ScoutApm
             layer = req.current_layer
             if layer && layer.type == "ActiveRecord"
               layer.annotate_layer(payload)
-            else
+            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.
             end
           end
         end
@@ -120,7 +134,7 @@ module ScoutApm
             current_layer.desc = desc
           end
 
-          log_without_scout_instruments(sql, name, &block)
+          log_without_scout_instruments(*args, &block)
 
         # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
         else
@@ -128,7 +142,7 @@ module ScoutApm
           layer.desc = desc
           req.start_layer(layer)
           begin
-            log_without_scout_instruments(sql, name, &block)
+            log_without_scout_instruments(*args, &block)
           ensure
             req.stop_layer
           end
@@ -206,5 +220,115 @@ module ScoutApm
         end
       end
     end
+
+    module ActiveRecordUpdateInstruments
+      def self.included(instrumented_class)
+        ScoutApm::Agent.instance.logger.info "Instrumenting ActiveRecord Save: - #{instrumented_class.inspect}"
+        instrumented_class.class_eval do
+          unless instrumented_class.method_defined?(:save_without_scout_instruments)
+            alias_method :save_without_scout_instruments, :save
+            alias_method :save, :save_with_scout_instruments
+          end
+
+          unless instrumented_class.method_defined?(:"savebang_without_scout_instruments")
+            alias_method :"savebang_without_scout_instruments", :"save!"
+            alias_method :"save!", :"savebang_with_scout_instruments"
+          end
+        end
+
+      end
+
+      def savebang_with_scout_instruments(*args, &block)
+        model = self.class.name
+        operation = self.persisted? ? "Update" : "Create"
+
+        req = ScoutApm::RequestManager.lookup
+        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} #{operation}"))
+        req.start_layer(layer)
+        req.ignore_children!
+        begin
+          savebang_without_scout_instruments(*args, &block)
+        ensure
+          req.acknowledge_children!
+          req.stop_layer
+        end
+      end
+
+      def save_with_scout_instruments(*args, &block)
+        model = self.class.name
+        operation = self.persisted? ? "Update" : "Create"
+
+        req = ScoutApm::RequestManager.lookup
+        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} #{operation}"))
+        req.start_layer(layer)
+        req.ignore_children!
+        begin
+          save_without_scout_instruments(*args, &block)
+        ensure
+          req.acknowledge_children!
+          req.stop_layer
+        end
+      end
+    end
+
+    module ActiveRecordRelationInstruments
+      def self.included(instrumented_class)
+        ::ActiveRecord::Relation.class_eval do
+          alias_method :update_all_without_scout_instruments, :update_all
+          alias_method :update_all, :update_all_with_scout_instruments
+
+          alias_method :delete_all_without_scout_instruments, :delete_all
+          alias_method :delete_all, :delete_all_with_scout_instruments
+
+          alias_method :destroy_all_without_scout_instruments, :destroy_all
+          alias_method :destroy_all, :destroy_all_with_scout_instruments
+        end
+      end
+
+      def update_all_with_scout_instruments(*args, &block)
+        model = self.name
+
+        req = ScoutApm::RequestManager.lookup
+        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} Update"))
+        req.start_layer(layer)
+        req.ignore_children!
+        begin
+          update_all_without_scout_instruments(*args, &block)
+        ensure
+          req.acknowledge_children!
+          req.stop_layer
+        end
+      end
+
+      def delete_all_with_scout_instruments(*args, &block)
+        model = self.name
+
+        req = ScoutApm::RequestManager.lookup
+        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} Delete"))
+        req.start_layer(layer)
+        req.ignore_children!
+        begin
+          delete_all_without_scout_instruments(*args, &block)
+        ensure
+          req.acknowledge_children!
+          req.stop_layer
+        end
+      end
+
+      def destroy_all_with_scout_instruments(*args, &block)
+        model = self.name
+
+        req = ScoutApm::RequestManager.lookup
+        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} Delete"))
+        req.start_layer(layer)
+        req.ignore_children!
+        begin
+          destroy_all_without_scout_instruments(*args, &block)
+        ensure
+          req.acknowledge_children!
+          req.stop_layer
+        end
+      end
+    end
   end
 end

data/lib/scout_apm/instruments/grape.rb

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

data/lib/scout_apm/instruments/middleware_detailed.rb

@@ -1,13 +1,11 @@
 # Inserts a new middleware between each actual middleware in the application,
 # so as to trace the time for each one.
 #
-# 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.
+# 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.
 #
-# 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.
+# Turn this on with the configuration setting `detailed_middleware` set to true
 module ScoutApm
   module Instruments
     class MiddlewareDetailed

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? && defined?(::Mongoid::Contextual::Mongo)
-            ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 5.x"
+          if (mongoid_v5? || mongoid_v6?) && defined?(::Mongoid::Contextual::Mongo)
+            ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 5.x/6.x"
             # All the public methods from Mongoid::Contextual::Mongo.
             # TODO: Geo and MapReduce support (?). They are in other Contextual::* classes
             methods = [
@@ -50,11 +50,24 @@ 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}"
-                  filter = ScoutApm::Instruments::Mongoid.anonymize_filter(view.filter)
+
+                  # 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)
 
                   layer = ScoutApm::Layer.new("MongoDB", name)
                   layer.desc = filter.inspect
@@ -86,6 +99,14 @@ 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.