scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/instant/middleware.rb

@@ -5,11 +5,6 @@ module ScoutApm
     class Page
       def initialize(html)
         @html = html
-
-        if html.is_a?(Array)
-          @html = html.inject("") { |memo, str| memo + str }
-        end
-
         @to_add_to_head = []
         @to_add_to_body = []
       end
@@ -50,206 +45,63 @@ module ScoutApm
       end
 
       def call(env)
-        rack_response = @app.call(env)
-        begin
-          DevTraceResponseManipulator.new(env, rack_response).call
-        rescue Exception => e
-          # If anything went wrong at all, just bail out and return the unmodified response.
-          ScoutApm::Agent.instance.context.logger.debug("DevTrace: Raised an exception: #{e.message}, #{e.backtrace}")
-          rack_response
-        end
-      end
-    end
-
-    class DevTraceResponseManipulator
-      attr_reader :rack_response
-      attr_reader :rack_status, :rack_headers, :rack_body
-      attr_reader :env
-
-      def initialize(env, rack_response)
-        @env = env
-        @rack_response = rack_response
-
-        @rack_status = rack_response[0]
-        @rack_headers = rack_response[1]
-        @rack_body = rack_response[2]
-      end
-
-      def call
-        return rack_response unless preconditions_met?
-
-        if ajax_request?
-          ScoutApm::Agent.instance.context.logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body. This is either AJAX or JSON. Path=#{path}; ContentType=#{content_type}")
-          adjust_ajax_header
-        else
-          adjust_html_response
-        end
-
-        rebuild_rack_response
-      end
-
-      ###########################
-      #  Precondition checking  #
-      ###########################
-
-      def preconditions_met?
-        if dev_trace_disabled?
-          # 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
-
-        # Don't attempt to instrument assets.
-        # Don't log this case, since it would be very noisy
-        logger.debug("DevTrace: dev asset ignored") and return false if development_asset?
-
-        # If we didn't have a tracked_request object, or we explicitly ignored
-        # this request, don't do any work.
-        logger.debug("DevTrace: no tracked request") and return false if tracked_request.nil? || tracked_request.ignoring_request?
-
-        # If we didn't get a trace, we can't show a trace...
-        if trace.nil?
-          logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body, but no trace was found. Path=#{path}; ContentType=#{content_type}")
-          return false
-        end
-
-        true
-      end
-
-      def dev_trace_disabled?
-        ! ScoutApm::Agent.instance.context.config.value('dev_trace')
-      end
-
-      ########################
-      #  Response Injection  #
-      ########################
-
-      def rebuild_rack_response
-        [rack_status, rack_headers, rack_body]
-      end
-
-      def adjust_ajax_header
-        rack_headers['X-scoutapminstant'] = payload
-      end
-
-      def adjust_html_response
-        case true
-        when older_rails_response? then adjust_older_rails_response
-        when newer_rails_response? then adjust_newer_rails_response
-        when rack_proxy_response? then  adjust_rack_proxy_response
+        status, headers, response = @app.call(env)
+        path, content_type = env['PATH_INFO'], headers['Content-Type']
+        if ScoutApm::Agent.instance.config.value('dev_trace')
+          if response.respond_to?(:body)
+            req = ScoutApm::RequestManager.lookup
+            slow_converter = LayerConverters::SlowRequestConverter.new(req)
+            trace = slow_converter.call
+            if trace
+              metadata = {
+                  :app_root      => ScoutApm::Environment.instance.root.to_s,
+                  :unique_id     => env['action_dispatch.request_id'], # note, this is a different unique_id than what "normal" payloads use
+                  :agent_version => ScoutApm::VERSION,
+                  :platform      => "ruby",
+              }
+              hash = ScoutApm::Serializers::PayloadSerializerToJson.rearrange_slow_transaction(trace)
+              hash.merge!(:metadata => metadata)
+              payload = ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(hash)
+
+              if env['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest' || content_type.include?("application/json")
+                ScoutApm::Agent.instance.logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body. This is either AJAX or JSON. Path=#{path}; ContentType=#{content_type}")
+                # Add the payload as a header if it's an AJAX call or JSON
+                headers['X-scoutapminstant'] = payload
+                [status, headers, response]
+              else
+                # otherwise, attempt to add it inline in the page, along with the appropriate JS & CSS. Note, if page doesn't have a head or body,
+                #duration = (req.root_layer.total_call_time*1000).to_i
+                apm_host=ScoutApm::Agent.instance.config.value("direct_host")
+                page = ScoutApm::Instant::Page.new(response.body)
+                page.add_to_head(ScoutApm::Instant::Util.read_asset("xmlhttp_instrumentation.html")) # This monkey-patches XMLHttpRequest. It could possibly be part of the main scout_instant.js too. Putting it here so it runs as soon as possible.
+                page.add_to_head("<link href='#{apm_host}/instant/scout_instant.css?cachebust=#{Time.now.to_i}' media='all' rel='stylesheet' />")
+                page.add_to_body("<script src='#{apm_host}/instant/scout_instant.js?cachebust=#{Time.now.to_i}'></script>")
+                page.add_to_body("<script>var scoutInstantPageTrace=#{payload};window.scoutInstant=window.scoutInstant('#{apm_host}', scoutInstantPageTrace)</script>")
+
+                if response.is_a?(ActionDispatch::Response)
+                  ScoutApm::Agent.instance.logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body. This appears to be an HTML page and an ActionDispatch::Response. Path=#{path}; ContentType=#{content_type}")
+                  # preserve the ActionDispatch::Response when applicable
+                  response.body=[page.res]
+                  [status, headers, response]
+                else
+                  ScoutApm::Agent.instance.logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body. This appears to be an HTML page but not an ActionDispatch::Response. Path=#{path}; ContentType=#{content_type}")
+                  # otherwise, just return an array
+                  [status, headers, [page.res]]
+                end
+              end
+            else
+              ScoutApm::Agent.instance.logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body, but no trace was found. Path=#{path}; ContentType=#{content_type}")
+              [status, headers, response]
+            end
+          else
+            # don't log anything here - this is the path for all assets served in development, and the log would get noisy
+            [status, headers, response]
+          end
         else
-          # No action taken, we only adjust if we know exactly what we have.
+          ScoutApm::Agent.instance.logger.debug("DevTrace: isn't activated via config. Try: SCOUT_DEV_TRACE=true rails server")
+          [status, headers, response]
         end
       end
-
-      def older_rails_response?
-        if defined?(ActionDispatch::Response)
-          return true if rack_body.is_a?(ActionDispatch::Response)
-        end
-      end
-
-      def newer_rails_response?
-        if defined?(ActionDispatch::Response::RackBody)
-          return true if rack_body.is_a?(ActionDispatch::Response::RackBody)
-        end
-      end
-
-      def rack_proxy_response?
-        rack_body.is_a?(::Rack::BodyProxy)
-      end
-
-      def adjust_older_rails_response
-        logger.debug("DevTrace: in middleware, dev_trace is active, and response has a (older) body. This appears to be an HTML page and an ActionDispatch::Response. Path=#{path}; ContentType=#{content_type}")
-        rack_body.body = [ html_manipulator.res ]
-      end
-
-      # Preserve the ActionDispatch::Response object we're working with
-      def adjust_newer_rails_response
-        logger.debug("DevTrace: in middleware, dev_trace is active, and response has a (newer) body. This appears to be an HTML page and an ActionDispatch::Response. Path=#{path}; ContentType=#{content_type}")
-        @rack_body = [ html_manipulator.res ]
-      end
-
-      def adjust_rack_proxy_response
-        logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body. This appears to be an HTML page and an Rack::BodyProxy. Path=#{path}; ContentType=#{content_type}")
-        @rack_body = [ html_manipulator.res ]
-        @rack_headers.delete("Content-Length")
-      end
-
-      def html_manipulator
-        @html_manipulator ||=
-          begin
-            page = ScoutApm::Instant::Page.new(rack_body.body)
-
-            # This monkey-patches XMLHttpRequest. It could possibly be part of the main scout_instant.js too. Putting it here so it runs as soon as possible.
-            page.add_to_head(ScoutApm::Instant::Util.read_asset("xmlhttp_instrumentation.html"))
-
-            # Add a link to CSS, then JS
-            page.add_to_head("<link href='#{apm_host}/instant/scout_instant.css?cachebust=#{Time.now.to_i}' media='all' rel='stylesheet' />")
-            page.add_to_body("<script src='#{apm_host}/instant/scout_instant.js?cachebust=#{Time.now.to_i}'></script>")
-            page.add_to_body("<script>var scoutInstantPageTrace=#{payload};window.scoutInstant=window.scoutInstant('#{apm_host}', scoutInstantPageTrace)</script>")
-
-            page
-          end
-      end
-
-      def ajax_request?
-        env['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest' || content_type.include?("application/json")
-      end
-
-      def development_asset?
-        !rack_body.respond_to?(:body)
-      end
-
-      def path
-        env['PATH_INFO']
-      end
-
-      def content_type
-        rack_headers['Content-Type']
-      end
-
-      ##############################
-      #  APM Helpers & Shorthands  #
-      ##############################
-
-      def logger
-        ScoutApm::Agent.instance.context.logger
-      end
-
-      def tracked_request
-        @tracked_request ||= ScoutApm::RequestManager.lookup
-      end
-
-      def apm_host
-        ScoutApm::Agent.instance.context.config.value("direct_host")
-      end
-
-      def trace
-        @trace ||=
-          begin
-            layer_finder = LayerConverters::FindLayerByType.new(tracked_request)
-            converter = LayerConverters::SlowRequestConverter.new(ScoutApm::Agent.instance.context, tracked_request, layer_finder, ScoutApm::FakeStore.new)
-            converter.call
-          end
-      end
-
-      def payload
-        @payload ||=
-          begin
-            metadata = {
-              :app_root      => ScoutApm::Agent.instance.context.environment.root.to_s,
-              :unique_id     => env['action_dispatch.request_id'], # note, this is a different unique_id than what "normal" payloads use
-              :agent_version => ScoutApm::VERSION,
-              :platform      => "ruby",
-            }
-
-            hash = ScoutApm::Serializers::PayloadSerializerToJson.
-              rearrange_slow_transaction(trace).
-              merge!(:metadata => metadata)
-            ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(hash)
-          end
-      end
-
     end
   end
 end

data/lib/scout_apm/instant_reporting.rb

@@ -15,12 +15,12 @@ module ScoutApm
         # Serialize that trace. We reuse the PayloadSerializer, but only provide the metadata and traces.
         # In this case, the traces array will always have just one element.
         metadata = {
-          :app_root      => ScoutApm::Agent.instance.context.environment.root.to_s,
-          :unique_id     => ScoutApm::Utils::UniqueId.simple,
-          :agent_version => ScoutApm::VERSION,
-          :agent_time    => Time.now.iso8601,
-          :agent_pid     => Process.pid,
-          :platform      => "ruby",
+            :app_root      => ScoutApm::Environment.instance.root.to_s,
+            :unique_id     => ScoutApm::Utils::UniqueId.simple,
+            :agent_version => ScoutApm::VERSION,
+            :agent_time    => Time.now.iso8601,
+            :agent_pid     => Process.pid,
+            :platform      => "ruby",
         }
 
         metrics = []
@@ -31,7 +31,7 @@ module ScoutApm
         payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, traces, jobs, slow_jobs)
 
         # Hand it off to the reporter for POST to our servers
-        reporter = Reporter.new(context, :instant_trace, @instant_key)
+        reporter = Reporter.new(:instant_trace, Agent.instance.config, Agent.instance.logger, @instant_key)
         reporter.report(payload, {'Content-Type' => 'application/json'} )
       end
     end

data/lib/scout_apm/instruments/action_controller_rails_2.rb

@@ -1,31 +1,27 @@
 module ScoutApm
   module Instruments
     class ActionControllerRails2
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(::ActionController) && defined?(::ActionController::Base)
-          @installed = true
+        @installed = true
 
+        if defined?(::ActionController) && defined?(::ActionController::Base)
           ::ActionController::Base.class_eval do
             include ScoutApm::Tracer
             include ::ScoutApm::Instruments::ActionControllerRails2Instruments
           end
 
-          logger.info "Instrumenting ActionView::Template"
+          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::Template"
           ::ActionView::Template.class_eval do
             include ::ScoutApm::Tracer
             instrument_method :render, :type => "View", :name => '#{path[%r{^(/.*/)?(.*)$},2]}/Rendering', :scope => true
@@ -37,8 +33,7 @@ module ScoutApm
 
     module ActionControllerRails2Instruments
       def self.included(instrumented_class)
-        # XXX: Don't lookup context by global
-        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
+        ScoutApm::Agent.instance.logger.info "Instrumenting #{instrumented_class.inspect}"
         instrumented_class.class_eval do
           unless instrumented_class.method_defined?(:perform_action_without_scout_instruments)
             alias_method :perform_action_without_scout_instruments, :perform_action
@@ -54,11 +49,10 @@ 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.
-        if ScoutApm::Agent.instance.context.config.value('collect_remote_ip')
-          req.context.add_user(:ip => request.remote_ip)
-        end
+        req.context.add_user(:ip => request.remote_ip)
         req.set_headers(request.headers)
         req.start_layer( ScoutApm::Layer.new("Controller", "#{controller_path}/#{action_name}") )
+        req.web!
 
         begin
           perform_action_without_scout_instruments(*args, &block)

data/lib/scout_apm/instruments/action_controller_rails_3_rails4.rb

@@ -2,159 +2,111 @@ module ScoutApm
   module Instruments
     # instrumentation for Rails 3 and Rails 4 is the same.
     class ActionControllerRails3Rails4
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
-      def installed!
+      def install
         @installed = true
-      end
 
-      def install
-        if !defined?(::ActiveSupport)
-          return
+        # 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) && 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
 
-        # 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
+        if defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
+          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::PartialRenderer"
+          ::ActionView::PartialRenderer.class_eval do
+            include ScoutApm::Tracer
 
-        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
+            instrument_method :render_partial,
+              :type => "View",
+              :name => '#{@template.virtual_path rescue "Unknown Partial"}/Rendering',
+              :scope => true
 
-          # 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)
-            this.logger.info "Instrumenting ActionController::Base"
-            ::ActionController::Base.class_eval do
-              include ScoutApm::Instruments::ActionControllerBaseInstruments
-            end
+            instrument_method :collection_with_template,
+              :type => "View",
+              :name => '#{@template.virtual_path rescue "Unknown Collection"}/Rendering',
+              :scope => true
           end
 
-          if defined?(::ActionController::Metal)
-            this.logger.info "Instrumenting ActionController::Metal"
-            ::ActionController::Metal.class_eval do
-              include ScoutApm::Instruments::ActionControllerMetalInstruments
-            end
-          end
-
-          if defined?(::ActionController::API)
-            this.logger.info "Instrumenting ActionController::Api"
-            ::ActionController::API.class_eval do
-              include ScoutApm::Instruments::ActionControllerAPIInstruments
-            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
-
-        ScoutApm::Agent.instance.context.logger.info("Instrumenting ActionController (hook installed)")
       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
-      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
+    module ActionControllerRails3Rails4Instruments
+      def process_action(*args)
+        req = ScoutApm::RequestManager.lookup
+        req.annotate_request(:uri => scout_transaction_uri(request))
 
-          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']
-              agent_context.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
-              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')
-                req.context.add_user(:ip => request.remote_ip) rescue nil
-              end
-              req.set_headers(request.headers)
-
-              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
+        # IP Spoofing Protection can throw an exception, just move on w/o remote ip
+        req.context.add_user(:ip => request.remote_ip) rescue nil
 
-    end
+        req.set_headers(request.headers)
 
-    module ActionControllerMetalInstruments
-      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
+        # 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
 
-      def scout_action_name(*args)
-        action_name = args[0]
-      end
-    end
+        req.web!
 
-    # Empty, noop module to provide compatibility w/ previous manual instrumentation
-    module ActionControllerRails3Rails4Instruments
-    end
+        layer = ScoutApm::Layer.new("Controller", "#{controller_path}/#{action_name}")
 
-    module ActionControllerBaseInstruments
-      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 # process_action
+
+      # Given an +ActionDispatch::Request+, formats the uri based on config settings.
+      def 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
+        end
       end
-    end
 
-    module ActionControllerAPIInstruments
-      include ScoutApm::Instruments::ActionControllerRails3Rails4.build_instrument_module
-
-      def scout_action_name(*args)
-        action_name
-      end
-    end
+    end # ActionControllerRails3Rails4Instruments
   end
 end