scout_apm 3.0.0.pre25 → 4.0.1

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/fake_store.rb

@@ -17,6 +17,9 @@ module ScoutApm
     def track_one!(type, name, value, options={})
     end
 
+    def track_trace!(trace, type)
+    end
+
     def track_histograms!(histograms, options={})
     end
 

data/lib/scout_apm/framework_integrations/rails_2.rb

@@ -15,7 +15,8 @@ module ScoutApm
 
       def present?
         defined?(::Rails) &&
-          defined?(ActionController) &&
+          defined?(::Rails::VERSION) &&
+            defined?(ActionController) &&
           Rails::VERSION::MAJOR < 3
       end
 

data/lib/scout_apm/framework_integrations/rails_3_or_4.rb

@@ -15,7 +15,8 @@ module ScoutApm
 
       def present?
         defined?(::Rails) &&
-          defined?(ActionController) &&
+          defined?(::Rails::VERSION) &&
+            defined?(ActionController) &&
           Rails::VERSION::MAJOR >= 3
       end
 
@@ -47,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
@@ -55,12 +57,21 @@ module ScoutApm
         end
       end
 
+      # Note, this code intentionally avoids `.respond_to?` because of an
+      # infinite loop created by the Textacular gem (tested against 3.2.2 of
+      # that gem), which some customers have installed.
+      #
+      # The loop was:
+      #   - Ask for database adapter
+      #   - Do .respond_to? on AR::Base to look for connection_config (which isn't present on some versions of rails)
+      #   - Textacular gem has a monkey-patch that queries the columns of the db
+      #     This obtains a connection, and runs a query.
+      #   - Scout tries to run SQLSanitizer against the query, which needs the database adapter.
+      #   - Goes back to first step.
+      #
+      # We avoid this issue by not calling .respond_to? here, and instead using the less optimal `rescue nil` approach
       def raw_database_adapter
-        adapter = if ActiveRecord::Base.respond_to?(:connection_config)
-                    ActiveRecord::Base.connection_config[:adapter].to_s
-                  else
-                    nil
-                  end
+        adapter = ActiveRecord::Base.connection_config[:adapter].to_s rescue nil
 
         if adapter.nil?
           adapter = ActiveRecord::Base.configurations[env]["adapter"]

data/lib/scout_apm/git_revision.rb

@@ -17,7 +17,7 @@ module ScoutApm
     private
 
     def detect
-      detect_from_env_var    ||
+      detect_from_config     ||
       detect_from_heroku     ||
       detect_from_capistrano ||
       detect_from_git
@@ -27,8 +27,11 @@ module ScoutApm
       ENV['HEROKU_SLUG_COMMIT']
     end
 
-    def detect_from_env_var
-      ENV['SCOUT_REVISION_SHA']
+    # Config will locate the value from:
+    #   ENV variable - SCOUT_REVISION_SHA
+    #   YAML setting - revision_sha
+    def detect_from_config
+      context.config.value('revision_sha')
     end
 
     def detect_from_capistrano

data/lib/scout_apm/instant/middleware.rb

@@ -94,7 +94,8 @@ module ScoutApm
 
       def preconditions_met?
         if dev_trace_disabled?
-          logger.debug("DevTrace: isn't activated via config. Try: SCOUT_DEV_TRACE=true rails server")
+          # The line below is very noise as it is called on every request.
+          # logger.debug("DevTrace: isn't activated via config. Try: SCOUT_DEV_TRACE=true rails server")
           return false
         end
 

data/lib/scout_apm/instrument_manager.rb

@@ -31,6 +31,7 @@ module ScoutApm
       install_instrument(ScoutApm::Instruments::Mongoid)
       install_instrument(ScoutApm::Instruments::NetHttp)
       install_instrument(ScoutApm::Instruments::HttpClient)
+      install_instrument(ScoutApm::Instruments::Memcached)
       install_instrument(ScoutApm::Instruments::Redis)
       install_instrument(ScoutApm::Instruments::InfluxDB)
       install_instrument(ScoutApm::Instruments::Elasticsearch)
@@ -41,13 +42,19 @@ module ScoutApm
       logger.warn $!.backtrace
     end
 
+    # Allows users to skip individual instruments via the config file
+    def skip_instrument?(instrument_klass)
+      instrument_short_name = instrument_klass.name.split("::").last
+      (config.value("disabled_instruments") || []).include?(instrument_short_name)
+    end
+
     private
 
     def install_instrument(instrument_klass)
       return if already_installed?(instrument_klass)
 
       if skip_instrument?(instrument_klass)
-        logger.info "Skipping Disabled Instrument: #{instrument_short_name} - To re-enable, change `disabled_instruments` key in scout_apm.yml"
+        logger.info "Skipping Disabled Instrument: #{instrument_klass} - To re-enable, change `disabled_instruments` key in scout_apm.yml"
         return
       end
 
@@ -56,12 +63,6 @@ module ScoutApm
       instance.install
     end
 
-    # Allows users to skip individual instruments via the config file
-    def skip_instrument?(instrument_klass)
-      instrument_short_name = instrument_klass.name.split("::").last
-      (config.value("disabled_instruments") || []).include?(instrument_short_name)
-    end
-
     def already_installed?(instrument_klass)
       @installed_instruments.any? do |already_installed_instrument|
         instrument_klass === already_installed_instrument

data/lib/scout_apm/instruments/action_controller_rails_2.rb

@@ -54,7 +54,9 @@ module ScoutApm
       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.
-        req.context.add_user(:ip => request.remote_ip)
+        if ScoutApm::Agent.instance.context.config.value('collect_remote_ip')
+          req.context.add_user(:ip => request.remote_ip)
+        end
         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

@@ -1,6 +1,6 @@
 module ScoutApm
   module Instruments
-    # instrumentation for Rails 3, 4, and 5 is the same.
+    # instrumentation for Rails 3 and Rails 4 is the same.
     class ActionControllerRails3Rails4
       attr_reader :context
 
@@ -17,37 +17,54 @@ 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
 
+        ScoutApm::Agent.instance.context.logger.info("Instrumenting ActionController (hook installed)")
       end
 
       # Returns a new anonymous module each time it is called. So
@@ -57,13 +74,24 @@ module ScoutApm
       # 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
+            agent_context = ScoutApm::Agent.instance.context
 
             # Check if this this request is to be reported instantly
             if instant_key = request.cookies['scoutapminstant']
-              ScoutApm::Agent.instance.context.logger.info "Instant trace request with key=#{instant_key} for path=#{path}"
+              agent_context.logger.info "Instant trace request with key=#{instant_key} for path=#{path}"
               req.instant_key = instant_key
             end
 
@@ -71,25 +99,20 @@ 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
-              req.context.add_user(:ip => request.remote_ip) rescue nil
+              if agent_context.config.value('collect_remote_ip')
+                req.context.add_user(:ip => request.remote_ip) rescue nil
+              end
               req.set_headers(request.headers)
 
               resolved_name = scout_action_name(*args)
-              layer = ScoutApm::Layer.new("Controller", "#{controller_path}/#{resolved_name}")
-
-              if enable_scoutprof? && ScoutApm::Agent.instance.context.config.value('profile') && ScoutApm::Instruments::Stacks::ENABLED
-                if defined?(ScoutApm::Instruments::Stacks::INSTALLED) && ScoutApm::Instruments::Stacks::INSTALLED
-                  # Capture ScoutProf if we can
-                  req.enable_profiled_thread!
-                  layer.set_root_class(self.class)
-                  layer.traced!
-                end
-              end
-
-              req.start_layer(layer)
+              req.start_layer( ScoutApm::Layer.new("Controller", "#{controller_path}/#{resolved_name}") )
               begin
                 super
               rescue
@@ -103,39 +126,25 @@ 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 ActionControllerBaseInstruments
+    module ActionControllerMetalInstruments
       include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
 
       def scout_action_name(*args)
-        action_name
+        action_name = args[0]
       end
+    end
 
-      def enable_scoutprof?
-        true
-      end
+    # Empty, noop module to provide compatibility w/ previous manual instrumentation
+    module ActionControllerRails3Rails4Instruments
     end
 
-    module ActionControllerMetalInstruments
+    module ActionControllerBaseInstruments
       include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
 
       def scout_action_name(*args)
-        action_name = args[0]
-      end
-
-      def enable_scoutprof?
-        false
+        action_name
       end
     end
 
@@ -145,14 +154,6 @@ module ScoutApm
       def scout_action_name(*args)
         action_name
       end
-
-      def enable_scoutprof?
-        false
-      end
-    end
-
-    # Empty, noop module to provide compatibility w/ previous manual instrumentation
-    module ActionControllerRails3Rails4Instruments
     end
   end
 end

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
-
-