newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -1,32 +1,32 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-require 'new_relic/agent/instrumentation/sinatra'
+# Our Padrino instrumentation relies heavily on the fact that Padrino is
+# built on Sinatra. Although it wires up a lot of its own routing logic,
+# we only need to patch into Padrino's dispatch to get things started.
+#
+# Parts of the Sinatra instrumentation (such as the TransactionNamer) are
+# aware of Padrino as a potential target in areas where both Sinatra and
+# Padrino run through the same code.
+
+require_relative 'sinatra'
+require_relative 'padrino/chain'
+require_relative 'padrino/instrumentation'
+require_relative 'padrino/prepend'
 
 DependencyDetection.defer do
   @name = :padrino
+  configure_with :sinatra
 
-  depends_on do
-    !NewRelic::Agent.config[:disable_sinatra] &&
-      defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods)
-  end
+  depends_on { defined?(Padrino) && defined?(Padrino::Routing::InstanceMethods) }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Padrino instrumentation'
-
-    # Our Padrino instrumentation relies heavily on the fact that Padrino is
-    # built on Sinatra. Although it wires up a lot of its own routing logic,
-    # we only need to patch into Padrino's dispatch to get things started.
-    #
-    # Parts of the Sinatra instrumentation (such as the TransactionNamer) are
-    # aware of Padrino as a potential target in areas where both Sinatra and
-    # Padrino run through the same code.
-    module ::Padrino::Routing::InstanceMethods
-      include NewRelic::Agent::Instrumentation::Sinatra
-
-      alias dispatch_without_newrelic dispatch!
-      alias dispatch! dispatch_with_newrelic
+    NewRelic::Agent.logger.info('Installing Padrino instrumentation')
+    if use_prepend?
+      prepend_instrument Padrino::Application, NewRelic::Agent::Instrumentation::PadrinoTracer::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::PadrinoTracer::Chain
     end
   end
 end

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

@@ -1,23 +1,23 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 DependencyDetection.defer do
   @name = :passenger
 
   depends_on do
-    defined?(::PhusionPassenger)
+    defined?(PhusionPassenger)
   end
 
   executes do
-    ::NewRelic::Agent.logger.debug "Installing Passenger event hooks."
+    NewRelic::Agent.logger.debug('Installing Passenger event hooks.')
 
-    ::PhusionPassenger.on_event(:stopping_worker_process) do
-      ::NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
+    PhusionPassenger.on_event(:stopping_worker_process) do
+      NewRelic::Agent.logger.debug('Passenger stopping this process, shutdown the agent.')
       NewRelic::Agent.instance.shutdown
     end
 
-    ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
       # We want to reset the stats from the stats engine in case any carried
       # over into the spawned process.  Don't clear them in case any were
       # cached.  We do this even in conservative spawning.

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

@@ -1,35 +1,32 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module Instrumentation
-      # https://newrelic.com/docs/features/tracking-front-end-time
+      # https://docs.newrelic.com/docs/features/tracking-front-end-time
       # Record queue time metrics based on any of three headers
       # which can be set on the request.
       module QueueTime
-        unless defined?(REQUEST_START_HEADER)
-          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_TIME = Time.at(946684800)
+        REQUEST_START_HEADER = 'HTTP_X_REQUEST_START'.freeze
+        QUEUE_START_HEADER = 'HTTP_X_QUEUE_START'.freeze
+        MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'.freeze
+        # any timestamps before this are thrown out and the parser
+        # will try again with a larger unit (2000/1/1 UTC)
+        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800).to_f
 
-          CANDIDATE_HEADERS = [
-            REQUEST_START_HEADER,
-            QUEUE_START_HEADER,
-            MIDDLEWARE_START_HEADER
-          ].freeze
+        CANDIDATE_HEADERS = [
+          REQUEST_START_HEADER,
+          QUEUE_START_HEADER,
+          MIDDLEWARE_START_HEADER
+        ].freeze
 
-          DIVISORS = [1_000_000, 1_000, 1]
-        end
+        DIVISORS = [1_000_000, 1_000, 1]
 
         module_function
 
-        def parse_frontend_timestamp(headers, now=Time.now)
+        def parse_frontend_timestamp(headers, now = Process.clock_gettime(Process::CLOCK_REALTIME))
           earliest = nil
 
           CANDIDATE_HEADERS.each do |header|
@@ -42,7 +39,7 @@ module NewRelic
           end
 
           if earliest && earliest > now
-            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now.to_f}")
+            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now}")
             earliest = now
           end
 
@@ -54,14 +51,14 @@ module NewRelic
           when /^\s*([\d+\.]+)\s*$/ then $1
           # following regexp intentionally unanchored to handle
           # (ie ignore) leading server names
-          when /t=([\d+\.]+)/       then $1
+          when /t=([\d+\.]+)/ then $1
           end
         end
 
         def parse_timestamp(string)
           DIVISORS.each do |divisor|
             begin
-              t = Time.at(string.to_f / divisor)
+              t = (string.to_f / divisor)
               return t if t > EARLIEST_ACCEPTABLE_TIME
             rescue RangeError
               # On Ruby versions built with a 32-bit time_t, attempting to

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

@@ -0,0 +1,66 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Rack
+    module Chain
+      def self.instrument!(builder_class)
+        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection(builder_class)
+
+        builder_class.class_eval do
+          include ::NewRelic::Agent::Instrumentation::RackBuilder
+
+          def to_app_with_newrelic_deferred_dependency_detection
+            with_deferred_dependency_detection { to_app_without_newrelic }
+          end
+
+          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 #{builder_class} middleware instrumentation")
+
+            def run_with_newrelic(app = nil, *args, &block)
+              app_or_block = app || block
+              run_with_tracing(app_or_block) do |wrapped|
+                # Rack::Builder#run for Rack v3+ supports a block, and does not
+                # support args. Whether a block or an app is provided, that
+                # callable object will be wrapped into a MiddlewareProxy
+                # instance. That proxy instance must then be passed to
+                # run_without_newrelic as the app argument.
+                block ? run_without_newrelic(wrapped, &nil) : run_without_newrelic(wrapped, *args)
+              end
+            end
+
+            alias_method(:run_without_newrelic, :run)
+            alias_method(:run, :run_with_newrelic)
+
+            def use_with_newrelic(middleware_class, *args, &block)
+              use_with_tracing(middleware_class) { |wrapped_class| use_without_newrelic(wrapped_class, *args, &block) }
+            end
+            ruby2_keywords(:use_with_newrelic) if respond_to?(:ruby2_keywords, true)
+
+            alias_method(:use_without_newrelic, :use)
+            alias_method(:use, :use_with_newrelic)
+          end
+        end
+      end
+    end
+
+    module URLMap
+      module Chain
+        def self.instrument!(url_map_class)
+          url_map_class.class_eval do
+            alias_method(:initialize_without_newrelic, :initialize)
+
+            def initialize(map = {})
+              traced_map = ::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
+              initialize_without_newrelic(traced_map)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module RackHelpers
+    def self.version_supported?
+      rack_version_supported? || puma_rack_version_supported?
+    end
+
+    def self.rack_version_supported?
+      return false unless defined? ::Rack
+
+      version = Gem::Version.new(::Rack.release)
+      min_version = Gem::Version.new('1.1.0')
+      version >= min_version
+    end
+
+    def self.puma_rack_version_supported?
+      return false unless defined? ::Puma::Const::PUMA_VERSION
+
+      version = Gem::Version.new(::Puma::Const::PUMA_VERSION)
+      # TODO: MAJOR VERSION - update min_version to 3.9.0
+      # min_version = Gem::Version.new('3.9.0')
+      min_version = Gem::Version.new('2.12.0')
+      version >= min_version
+    end
+
+    def self.middleware_instrumentation_enabled?
+      version_supported? && !::NewRelic::Agent.config[:disable_middleware_instrumentation]
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module RackBuilder
+        INSTRUMENTATION_NAME = 'Rack'
+
+        def self.track_deferred_detection(builder_class)
+          class << builder_class
+            attr_accessor :_nr_deferred_detection_ran
+          end
+          builder_class._nr_deferred_detection_ran = false
+        end
+
+        def deferred_dependency_check
+          return if self.class._nr_deferred_detection_ran
+
+          NewRelic::Agent.logger.info('Doing deferred dependency-detection before Rack startup')
+          DependencyDetection.detect!
+          self.class._nr_deferred_detection_ran = true
+        end
+
+        def check_for_late_instrumentation(app)
+          return if defined?(@checked_for_late_instrumentation) && @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
+
+        # We patch the #to_app 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 with_deferred_dependency_detection
+          deferred_dependency_check
+          yield.tap { |result| check_for_late_instrumentation(result) }
+        end
+
+        def middleware_instrumentation_enabled?
+          ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+        end
+
+        def run_with_tracing(app)
+          return yield(app) unless middleware_instrumentation_enabled?
+
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+          yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true))
+        end
+
+        def use_with_tracing(middleware_class)
+          return if middleware_class.nil?
+          return yield(middleware_class) unless middleware_instrumentation_enabled?
+
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+          yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class))
+        end
+      end
+
+      module RackURLMap
+        def self.generate_traced_map(map)
+          map.inject({}) do |traced_map, (url, handler)|
+            traced_map[url] = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(handler, true)
+            traced_map
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Rack
+    module URLMap
+      module Prepend
+        def initialize(map = {})
+          super(::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map))
+        end
+      end
+    end
+
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::RackBuilder
+
+      def self.prepended(builder_class)
+        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection(builder_class)
+      end
+
+      def to_app
+        with_deferred_dependency_detection { super }
+      end
+
+      def run(app = nil, *args, &block)
+        app_or_block = app || block
+        run_with_tracing(app_or_block) do |wrapped|
+          # Rack::Builder#run for Rack v3+ supports a block, and does not
+          # support args. Whether a block or an app is provided, that callable
+          # object will be wrapped into a MiddlewareProxy instance. That
+          # proxy instance must then be passed to super as the app argument.
+          block ? super(wrapped, &nil) : super(wrapped, *args)
+        end
+      end
+
+      def use(middleware_class, *args, &blk)
+        use_with_tracing(middleware_class) { |wrapped_class| super(wrapped_class, *args, &blk) }
+      end
+      ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+    end
+  end
+end

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

@@ -1,186 +1,83 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      # == Instrumentation for Rack
-      #
-      # 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
-        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 => :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
-
-        def self.extended middleware #:nodoc:
-          middleware.class_eval do
-            class << self
-              alias call_without_newrelic call
-              alias call call_with_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
-
-      module RackURLMap
-        def self.generate_traced_map(map)
-          map.inject({}) do |traced_map, (url, handler)|
-            traced_map[url] = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(handler, true)
-            traced_map
-          end
-        end
-      end
+require_relative 'rack/helpers'
+require_relative 'rack/instrumentation'
+require_relative 'rack/chain'
+require_relative 'rack/prepend'
+
+DependencyDetection.defer do
+  named :rack
+
+  depends_on do
+    defined?(Rack) && defined?(Rack::Builder)
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
+    else
+      chain_instrument_target Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
     end
   end
 end
 
 DependencyDetection.defer do
-  named :rack
+  named :puma_rack
 
   depends_on do
-    defined?(::Rack) && defined?(::Rack::Builder)
+    defined?(Puma::Rack::Builder)
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing deferred Rack instrumentation'
-
-    class ::Rack::Builder
-      class << self
-        attr_accessor :_nr_deferred_detection_ran
-      end
-      self._nr_deferred_detection_ran = false
+    if use_prepend?
+      prepend_instrument Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
+    else
+      chain_instrument_target Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
+    end
+  end
+end
 
-      include ::NewRelic::Agent::Instrumentation::RackBuilder
+DependencyDetection.defer do
+  named :rack_urlmap
 
-      alias_method :to_app_without_newrelic, :to_app
-      alias_method :to_app, :to_app_with_newrelic_deferred_dependency_detection
+  depends_on do
+    defined?(Rack) && defined?(Rack::URLMap)
+  end
 
-      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
+  depends_on do
+    NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+  end
 
-        alias_method :use_without_newrelic, :use
-        alias_method :use, :use_with_newrelic
-      end
+  executes do
+    if use_prepend?
+      prepend_instrument Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
+    else
+      chain_instrument_target Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
+      NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map
     end
-
   end
 end
 
 DependencyDetection.defer do
-  named :rack_urlmap
+  named :puma_rack_urlmap
 
   depends_on do
-    defined?(::Rack) && defined?(::Rack::URLMap)
+    defined?(Puma::Rack::URLMap)
   end
 
   depends_on do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled? &&
-      !::NewRelic::Agent.config[:disable_rack]
+    NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
   end
 
   executes do
-    class ::Rack::URLMap
-      alias_method :initialize_without_newrelic, :initialize
-
-      def initialize(map = {})
-        traced_map = ::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
-        initialize_without_newrelic(traced_map)
-      end
+    if use_prepend?
+      prepend_instrument Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
+    else
+      chain_instrument_target Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
     end
   end
 end