newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/agent/instrumentation/middleware_proxy.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'new_relic/agent/method_tracer'
+require 'new_relic/agent/transaction'
+require 'new_relic/agent/transaction_state'
+require 'new_relic/agent/instrumentation/queue_time'
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+require 'new_relic/agent/instrumentation/middleware_tracing'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class MiddlewareProxy
+        include MiddlewareTracing
+
+        # This class is used to wrap classes that are passed to
+        # Rack::Builder#use without synchronously instantiating those classes.
+        # A MiddlewareProxy::Generator responds to new, like a Class would, and
+        # passes through arguments to new to the original target class.
+        class Generator
+          def initialize(middleware_class)
+            @middleware_class = middleware_class
+          end
+
+          def new(*args, &blk)
+            middleware_instance = @middleware_class.new(*args, &blk)
+            MiddlewareProxy.wrap(middleware_instance)
+          end
+        end
+
+        def self.is_sinatra_app?(target)
+          defined?(::Sinatra::Base) && target.kind_of?(::Sinatra::Base)
+        end
+
+        def self.for_class(target_class)
+          Generator.new(target_class)
+        end
+
+        def self.needs_wrapping?(target)
+          (
+            !target.respond_to?(:_nr_has_middleware_tracing) &&
+            !is_sinatra_app?(target)
+          )
+        end
+
+        def self.wrap(target, is_app=false)
+          if needs_wrapping?(target)
+            self.new(target, is_app)
+          else
+            target
+          end
+        end
+
+        attr_reader :target, :category, :transaction_options
+
+        def initialize(target, is_app=false)
+          @target            = target
+          @is_app            = is_app
+          @category          = determine_category
+          @target_class_name = determine_class_name
+          @transaction_name  = "#{determine_prefix}#{@target_class_name}/call"
+          @transaction_options  = {
+            :transaction_name => @transaction_name
+          }
+        end
+
+        def determine_category
+          if @is_app
+            :rack
+          else
+            :middleware
+          end
+        end
+
+        def determine_prefix
+          ControllerInstrumentation::TransactionNamer.prefix_for_category(nil, @category)
+        end
+
+        # In 'normal' usage, the target will be an application instance that
+        # responds to #call. With Rails, however, the target may be a subclass
+        # of Rails::Application that defines a method_missing that proxies #call
+        # to a singleton instance of the the subclass. We need to ensure that we
+        # capture the correct name in both cases.
+        def determine_class_name
+          if @target.is_a?(Class)
+            @target.name
+          else
+            @target.class.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/middleware_tracing.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'new_relic/agent/method_tracer'
+require 'new_relic/agent/transaction'
+require 'new_relic/agent/transaction_state'
+require 'new_relic/agent/instrumentation/queue_time'
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+# This module is intended to be included into both MiddlewareProxy and our
+# internal middleware classes.
+#
+# Host classes must define two methods:
+#
+# * target: returns the original middleware being traced
+# * category: returns the category for the resulting agent transaction
+#             should be either :middleware or :rack
+# * transaction_options: returns an options hash to be passed to
+#                        Transaction.start when tracing this middleware.
+#
+# The target may be self, in which case the host class should define a
+# #traced_call method, instead of the usual #call.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module MiddlewareTracing
+        CAPTURED_REQUEST_KEY = 'newrelic.captured_request'.freeze unless defined?(CAPTURED_REQUEST_KEY)
+
+        def _nr_has_middleware_tracing
+          true
+        end
+
+        def build_transaction_options(env)
+          if env[CAPTURED_REQUEST_KEY]
+            transaction_options
+          else
+            env[CAPTURED_REQUEST_KEY] = true
+            queue_timefrontend_timestamp = QueueTime.parse_frontend_timestamp(env)
+            transaction_options.merge(
+              :request          => ::Rack::Request.new(env),
+              :apdex_start_time => queue_timefrontend_timestamp
+            )
+          end
+        end
+
+        def call(env)
+          opts = build_transaction_options(env)
+          state = NewRelic::Agent::TransactionState.tl_get
+
+          begin
+            txn = Transaction.start(state, category, opts)
+            if target == self
+              traced_call(env)
+            else
+              target.call(env)
+            end
+          rescue => e
+            txn.notice_error(e)
+            raise
+          ensure
+            Transaction.stop(state)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/net.rb

@@ -3,7 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 DependencyDetection.defer do
-  @name = :net
+  named :net_http
 
   depends_on do
     defined?(Net) && defined?(Net::HTTP)

data/lib/new_relic/agent/instrumentation/queue_time.rb

@@ -10,26 +10,34 @@ module NewRelic
       # which can be set on the request.
       module QueueTime
         unless defined?(REQUEST_START_HEADER)
-          REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'
-          QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'
-          QUEUE_DURATION_HEADER   = 'HTTP_X_QUEUE_TIME'
-          MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'
-          ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'
+          REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'.freeze
+          QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'.freeze
+          MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'.freeze
+          ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'.freeze
           # any timestamps before this are thrown out and the parser
           # will try again with a larger unit (2000/1/1 UTC)
           EARLIEST_ACCEPTABLE_TIMESTAMP = 946684800
+
+          CANDIDATE_HEADERS = [
+            REQUEST_START_HEADER,
+            QUEUE_START_HEADER,
+            MIDDLEWARE_START_HEADER
+          ].freeze
         end
 
         module_function
 
         def parse_frontend_timestamp(headers, now=Time.now)
-          candidate_headers = [ REQUEST_START_HEADER, QUEUE_START_HEADER,
-                                MIDDLEWARE_START_HEADER ]
-          earliest = candidate_headers.map do |header|
+          earliest = nil
+
+          CANDIDATE_HEADERS.each do |header|
             if headers[header]
-              parse_timestamp(timestamp_string_from_header_value(headers[header]))
+              parsed = parse_timestamp(timestamp_string_from_header_value(headers[header]))
+              if parsed && (!earliest || parsed < earliest)
+                earliest = parsed
+              end
             end
-          end.compact.min
+          end
 
           if earliest && earliest > now
             NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now.to_f}")
@@ -39,9 +47,9 @@ module NewRelic
           earliest
         end
 
-        def record_frontend_metrics(start_time, now=Time.now)
-          NewRelic::Agent.instance.stats_engine.record_metrics(
-            ALL_QUEUE_METRIC, (now - start_time).to_f, :scoped => true)
+        def record_frontend_metrics(start_time, now=Time.now) #THREAD_LOCAL_ACCESS
+          NewRelic::Agent.instance.stats_engine.tl_record_unscoped_metrics(
+            ALL_QUEUE_METRIC, (now - start_time).to_f)
         end
 
         def timestamp_string_from_header_value(value)

data/lib/new_relic/agent/instrumentation/rack.rb

@@ -9,87 +9,36 @@ module NewRelic
     module Instrumentation
       # == Instrumentation for Rack
       #
-      # New Relic will instrument a #call method as if it were a controller
-      # action, collecting transaction traces and errors.  The middleware will
-      # be identified only by its class, so if you want to instrument multiple
-      # actions in a middleware, you need to use
-      # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
-      #
-      # Example:
-      #   require 'newrelic_rpm'
-      #   require 'new_relic/agent/instrumentation/rack'
-      #   class Middleware
-      #     def call(env)
-      #       ...
-      #     end
-      #     # Do the include after the call method is defined:
-      #     include NewRelic::Agent::Instrumentation::Rack
-      #   end
-      #
-      # == Instrumenting Metal and Cascading Middlewares
-      #
-      # Metal apps and apps belonging to Rack::Cascade middleware
-      # follow a convention of returning a 404 for all requests except
-      # the ones they are set up to handle.  This means that New Relic
-      # needs to ignore these calls when they return a 404.
-      #
-      # In these cases, you should not include or extend the Rack
-      # module but instead include
-      # NewRelic::Agent::Instrumentation::ControllerInstrumentation.
-      # Here's how that might look for a Metal app:
-      #
-      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
-      #   class MetalApp
-      #     extend NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      #     def self.call(env)
-      #       if should_do_my_thing?
-      #         perform_action_with_newrelic_trace(:category => :rack) do
-      #           return my_response(env)
-      #         end
-      #       else
-      #         return [404, {"Content-Type" => "text/html"}, ["Not Found"]]
-      #       end
-      #     end
-      #   end
-      #
-      # == Overriding the metric name
-      #
-      # By default the middleware is identified only by its class, but if you want to
-      # be more specific and pass in name, then omit including the Rack instrumentation
-      # and instead follow this example:
-      #
-      #   require 'newrelic_rpm'
-      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
-      #   class Middleware
-      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      #     def call(env)
-      #       ...
-      #     end
-      #     add_transaction_tracer :call, :category => :rack, :name => 'my app'
-      #   end
+      # Since version 3.9.0, New Relic instruments Rack middlewares by default.
+      # As a result, this entire module has been deprecated.
       #
       # @api public
+      # @deprecated
       #
       module Rack
-        def newrelic_request_headers
+        include ControllerInstrumentation
+
+        def newrelic_request_headers(_)
           @newrelic_request.env
         end
+
         def call_with_newrelic(*args)
           @newrelic_request = ::Rack::Request.new(args.first)
-          perform_action_with_newrelic_trace(:category => :rack, :request => @newrelic_request) do
+          perform_action_with_newrelic_trace(:category => :middleware, :request => @newrelic_request) do
             result = call_without_newrelic(*args)
             # Ignore cascaded calls
             Transaction.abort_transaction! if result.first == 404
             result
           end
         end
+
         def self.included middleware #:nodoc:
           middleware.class_eval do
             alias call_without_newrelic call
             alias call call_with_newrelic
           end
         end
-        include ControllerInstrumentation
+
         def self.extended middleware #:nodoc:
           middleware.class_eval do
             class << self
@@ -98,12 +47,77 @@ module NewRelic
             end
           end
         end
+
+        def _nr_has_middleware_tracing
+          true
+        end
+      end
+
+      module RackHelpers
+        def self.rack_version_supported?
+          version = ::NewRelic::VersionNumber.new(::Rack.release)
+          min_version = ::NewRelic::VersionNumber.new('1.1.0')
+          version >= min_version
+        end
+
+        def self.middleware_instrumentation_enabled?
+          rack_version_supported? && !::NewRelic::Agent.config[:disable_middleware_instrumentation]
+        end
+
+        def self.check_for_late_instrumentation(app)
+          return if @checked_for_late_instrumentation
+          @checked_for_late_instrumentation = true
+          if middleware_instrumentation_enabled?
+            if ::NewRelic::Agent::Instrumentation::MiddlewareProxy.needs_wrapping?(app)
+              ::NewRelic::Agent.logger.info("We weren't able to instrument all of your Rack middlewares.",
+                                            "To correct this, ensure you 'require \"newrelic_rpm\"' before setting up your middleware stack.")
+            end
+          end
+        end
+      end
+
+      module RackBuilder
+        def run_with_newrelic(app, *args)
+          if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+            wrapped_app = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+            run_without_newrelic(wrapped_app, *args)
+          else
+            run_without_newrelic(app, *args)
+          end
+        end
+
+        def use_with_newrelic(middleware_class, *args, &blk)
+          if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+            wrapped_middleware_class = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+            use_without_newrelic(wrapped_middleware_class, *args, &blk)
+          else
+            use_without_newrelic(middleware_class, *args, &blk)
+          end
+        end
+
+        # We patch this method for a reason that actually has nothing to do with
+        # instrumenting rack itself. It happens to be a convenient and
+        # easy-to-hook point that happens late in the startup sequence of almost
+        # every application, making it a good place to do a final call to
+        # DependencyDetection.detect!, since all libraries are likely loaded at
+        # this point.
+        def to_app_with_newrelic_deferred_dependency_detection
+          unless ::Rack::Builder._nr_deferred_detection_ran
+            NewRelic::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
+            DependencyDetection.detect!
+            ::Rack::Builder._nr_deferred_detection_ran = true
+          end
+
+          result = to_app_without_newrelic
+          ::NewRelic::Agent::Instrumentation::RackHelpers.check_for_late_instrumentation(result)
+
+          result
+        end
       end
     end
   end
 end
 
-
 DependencyDetection.defer do
   named :rack
 
@@ -113,29 +127,26 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing deferred Rack instrumentation'
-  end
 
-  executes do
     class ::Rack::Builder
-
       class << self
         attr_accessor :_nr_deferred_detection_ran
       end
       self._nr_deferred_detection_ran = false
 
-      def to_app_with_newrelic_deferred_dependency_detection
-        unless Rack::Builder._nr_deferred_detection_ran
-          NewRelic::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
-          DependencyDetection.detect!
-          Rack::Builder._nr_deferred_detection_ran = true
-        end
-
-        to_app_without_newrelic
-      end
+      include ::NewRelic::Agent::Instrumentation::RackBuilder
 
       alias_method :to_app_without_newrelic, :to_app
       alias_method :to_app, :to_app_with_newrelic_deferred_dependency_detection
 
+      if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+        ::NewRelic::Agent.logger.info 'Installing Rack::Builder middleware instrumentation'
+        alias_method :run_without_newrelic, :run
+        alias_method :run, :run_with_newrelic
+
+        alias_method :use_without_newrelic, :use
+        alias_method :use, :use_with_newrelic
+      end
     end
   end
 end