scout_apm 3.0.0.pre26 → 4.0.2

data/lib/scout_apm/instruments/action_view.rb

@@ -1,6 +1,14 @@
+# Note, this instrument has the same logic in both Tracer and Module Prepend
+# versions. If you update, be sure you update in both spots.
+#
+# The prepend version was added for Rails 6 support - ActiveRecord prepends on
+# top of PartialRenderer#collection_with_template, which can (and does) cause
+# infinite loops with our alias_method approach.
+#
+# Even though Rails 6 forced us to use a prepend version, it is now used for
+# all Rubies that support it.
 module ScoutApm
   module Instruments
-    # instrumentation for Rails 3 and Rails 4 is the same.
     class ActionView
       attr_reader :context
 
@@ -17,37 +25,129 @@ module ScoutApm
         @installed
       end
 
+      def prependable?
+        context.environment.supports_module_prepend?
+      end
+
       def install
-        if defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
-          @installed = true
-
-          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
+        return unless defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
+
+        if prependable?
+          install_using_prepend
+        else
+          install_using_tracer
+        end
+        @installed = true
+      end
+
+      def install_using_tracer
+        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
+
+        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
+
+      def install_using_prepend
+        logger.info "Instrumenting ActionView::PartialRenderer"
+        ::ActionView::PartialRenderer.prepend(ActionViewPartialRendererInstruments)
+
+        logger.info "Instrumenting ActionView::TemplateRenderer"
+        ::ActionView::TemplateRenderer.prepend(ActionViewTemplateRendererInstruments)
+      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, **kwargs)
+          req = ScoutApm::RequestManager.lookup
+
+          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 = ScoutApm::Layer.new("View", layer_name)
+          layer.subscopable!
+
+          begin
+            req.start_layer(layer)
+            if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+              super(*args, **kwargs)
+            else
+              super(*args)
+            end
+          ensure
+            req.stop_layer
+          end
+        end
+
+        def collection_with_template(*args, **kwargs)
+          req = ScoutApm::RequestManager.lookup
+
+          template_name = @template.virtual_path rescue "Unknown Collection"
+          template_name ||= "Unknown Collection"
+          layer_name = template_name + "/Rendering"
+
+          layer = ScoutApm::Layer.new("View", layer_name)
+          layer.subscopable!
+
+          begin
+            req.start_layer(layer)
+            if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+              super(*args, **kwargs)
+            else
+              super(*args)
+            end
+          ensure
+            req.stop_layer
           end
+        end
+      end
+
+      module ActionViewTemplateRendererInstruments
+        def render_template(*args, **kwargs)
+          req = ScoutApm::RequestManager.lookup
 
-          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
+          template_name = args[0].virtual_path rescue "Unknown"
+          template_name ||= "Unknown"
+          layer_name = template_name + "/Rendering"
+
+          layer = ScoutApm::Layer.new("View", layer_name)
+          layer.subscopable!
+
+          begin
+            req.start_layer(layer)
+            if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+              super(*args, **kwargs)
+            else
+              super(*args)
+            end
+          ensure
+            req.stop_layer
           end
         end
       end
     end
   end
 end
-
-

data/lib/scout_apm/instruments/active_record.rb

@@ -82,10 +82,8 @@ module ScoutApm
 
         # Install #log tracing
         if Utils::KlassHelper.defined?("ActiveRecord::ConnectionAdapters::AbstractAdapter")
-          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-            include ::ScoutApm::Instruments::ActiveRecordInstruments
-            include ::ScoutApm::Tracer
-          end
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecordInstruments)
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Tracer)
         end
 
         if Utils::KlassHelper.defined?("ActiveRecord::Base")
@@ -168,17 +166,63 @@ module ScoutApm
     #
     ################################################################################
     module ActiveRecordInstruments
-      def self.included(instrumented_class)
+      def self.prepended(instrumented_class)
         ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
-        instrumented_class.class_eval do
-          unless instrumented_class.method_defined?(:log_without_scout_instruments)
-            alias_method :log_without_scout_instruments, :log
-            alias_method :log, :log_with_scout_instruments
+      end
+
+      def log(*args, &block)
+        # Extract data from the arguments
+        sql, name = args
+        metric_name = Utils::ActiveRecordMetricName.new(sql, name)
+        desc = SqlList.new(sql)
+
+        # Get current ScoutApm context
+        req = ScoutApm::RequestManager.lookup
+        current_layer = req.current_layer
+
+        # If we call #log, we have a real query to run, and we've already
+        # gotten through the cache gatekeeper. Since we want to only trace real
+        # queries, and not repeated identical queries that just hit cache, we
+        # mark layer as ignorable initially in #find_by_sql, then only when we
+        # know it's a real database call do we mark it back as usable.
+        #
+        # This flag is later used in SlowRequestConverter to skip adding ignorable layers
+        current_layer.annotate_layer(:ignorable => false) if current_layer
+
+        # Either: update the current layer and yield, don't start a new one.
+        if current_layer && current_layer.type == "ActiveRecord"
+          # TODO: Get rid of call .to_s, need to find this without forcing a previous run of the name logic
+          if current_layer.name.to_s == Utils::ActiveRecordMetricName::DEFAULT_METRIC
+            current_layer.name = metric_name
+          end
+
+          if current_layer.desc.nil?
+            current_layer.desc = SqlList.new
+          end
+          current_layer.desc.merge(desc)
+
+          super(*args, &block)
+
+        # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
+        else
+          layer = ScoutApm::Layer.new("ActiveRecord", metric_name)
+          layer.desc = desc
+          req.start_layer(layer)
+          begin
+            super(*args, &block)
+          ensure
+            req.stop_layer
           end
         end
       end
+    end
 
-      def log_with_scout_instruments(*args, &block)
+    module ActiveRecordInstruments
+      def self.prepended(instrumented_class)
+        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
+      end
+
+      def log(*args, &block)
         # Extract data from the arguments
         sql, name = args
         metric_name = Utils::ActiveRecordMetricName.new(sql, name)
@@ -209,7 +253,7 @@ module ScoutApm
           end
           current_layer.desc.merge(desc)
 
-          log_without_scout_instruments(*args, &block)
+          super(*args, &block)
 
         # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
         else
@@ -217,7 +261,7 @@ module ScoutApm
           layer.desc = desc
           req.start_layer(layer)
           begin
-            log_without_scout_instruments(*args, &block)
+            super(*args, &block)
           ensure
             req.stop_layer
           end
@@ -264,14 +308,18 @@ module ScoutApm
         end
       end
 
-      def find_by_sql_with_scout_instruments(*args, &block)
+      def find_by_sql_with_scout_instruments(*args, **kwargs, &block)
         req = ScoutApm::RequestManager.lookup
         layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName::DEFAULT_METRIC)
         layer.annotate_layer(:ignorable => true)
         req.start_layer(layer)
         req.ignore_children!
         begin
-          find_by_sql_without_scout_instruments(*args, &block)
+          if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+            find_by_sql_without_scout_instruments(*args, **kwargs, &block)
+          else
+            find_by_sql_without_scout_instruments(*args, &block)
+          end
         ensure
           req.acknowledge_children!
           req.stop_layer
@@ -349,7 +397,7 @@ module ScoutApm
     end
 
     module ActiveRecordUpdateInstruments
-      def save(*args, &block)
+      def save(*args, **options, &block)
         model = self.class.name
         operation = self.persisted? ? "Update" : "Create"
 
@@ -359,14 +407,14 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          super(*args, &block)
+          super(*args, **options, &block)
         ensure
           req.acknowledge_children!
           req.stop_layer
         end
       end
 
-      def save!(*args, &block)
+      def save!(*args, **options, &block)
         model = self.class.name
         operation = self.persisted? ? "Update" : "Create"
 
@@ -375,7 +423,7 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          super(*args, &block)
+          super(*args, **options, &block)
         ensure
           req.acknowledge_children!
           req.stop_layer

data/lib/scout_apm/instruments/http.rb

@@ -0,0 +1,48 @@
+module ScoutApm
+  module Instruments
+    class HTTP
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+        @installed = false
+      end
+
+      def logger
+        context.logger
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        if defined?(::HTTP) && defined?(::HTTP::Client)
+          @installed = true
+
+          logger.info "Instrumenting HTTP::Client"
+
+          ::HTTP::Client.class_eval do
+            include ScoutApm::Tracer
+
+            def request_with_scout_instruments(verb, uri, opts = {})
+              self.class.instrument("HTTP", verb, :ignore_children => true, :desc => request_scout_description(verb, uri)) do
+                request_without_scout_instruments(verb, uri, opts)
+              end
+            end
+
+            def request_scout_description(verb, uri)
+              max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
+              (String(uri).split('?').first)[0..(max_length - 1)]
+            rescue
+              ""
+            end
+
+            alias request_without_scout_instruments request
+            alias request request_with_scout_instruments
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/memcached.rb

@@ -0,0 +1,43 @@
+module ScoutApm
+  module Instruments
+    class Memcached
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+        @installed = false
+      end
+
+      def logger
+        context.logger
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        if defined?(::Dalli) && defined?(::Dalli::Client)
+          @installed = true
+
+          logger.info "Instrumenting Memcached"
+
+          ::Dalli::Client.class_eval do
+            include ScoutApm::Tracer
+
+            def perform_with_scout_instruments(*args, &block)
+              command = args.first rescue "Unknown"
+
+              self.class.instrument("Memcached", command) do
+                perform_without_scout_instruments(*args, &block)
+              end
+            end
+
+            alias_method :perform_without_scout_instruments, :perform
+            alias_method :perform, :perform_with_scout_instruments
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/mongoid.rb

@@ -37,8 +37,8 @@ module ScoutApm
           ### See moped instrument for Moped driven deploys
 
           ### 5.x Mongoid
-          if (mongoid_v5? || mongoid_v6?) && defined?(::Mongoid::Contextual::Mongo)
-            logger.info "Instrumenting Mongoid 5.x/6.x"
+          if (mongoid_v5? || mongoid_v6? || mongoid_v7?) && defined?(::Mongoid::Contextual::Mongo)
+            logger.info "Instrumenting Mongoid 5.x/6.x/7.x"
             # All the public methods from Mongoid::Contextual::Mongo.
             # TODO: Geo and MapReduce support (?). They are in other Contextual::* classes
             methods = [
@@ -54,8 +54,6 @@ module ScoutApm
               if ::Mongoid::Contextual::Mongo.method_defined?(method)
                 with_scout_instruments = %Q[
                 def #{method}_with_scout_instruments(*args, &block)
-
-
                   req = ScoutApm::RequestManager.lookup
                   *db, collection = view.collection.namespace.split(".")
 
@@ -112,6 +110,13 @@ module ScoutApm
         end
       end
 
+      def mongoid_v7?
+        if defined?(::Mongoid::VERSION)
+          ::Mongoid::VERSION =~ /\A7/
+        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.