newrelic_rpm 6.15.0 → 8.13.1

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

@@ -0,0 +1,44 @@
+# 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
+
+require_relative 'net_http/chain'
+require_relative 'net_http/prepend'
+
+DependencyDetection.defer do
+  named :net_http
+
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info('Installing Net:HTTP Wrappers')
+    require 'new_relic/agent/http_clients/net_http_wrappers'
+  end
+
+  # Airbrake uses method chaining on Net::HTTP in versions < 10.0.2 (10.0.2 updated to prepend for Net:HTTP)
+  conflicts_with_prepend do
+    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('10.0.2')
+  end
+
+  conflicts_with_prepend do
+    defined?(::ScoutApm)
+  end
+
+  conflicts_with_prepend do
+    defined?(::Rack::MiniProfiler)
+  end
+
+  conflicts_with_prepend do
+    source_location_for(Net::HTTP, "request") =~ /airbrake|profiler/i
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument ::Net::HTTP, ::NewRelic::Agent::Instrumentation::NetHTTP::Prepend
+    else
+      chain_instrument ::NewRelic::Agent::Instrumentation::NetHTTP::Chain
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
@@ -12,7 +12,7 @@ module NewRelic
         end
 
         def self.subscribed?
-          find_all_subscribers.find{|s| s.instance_variable_get(:@delegate).class == self }
+          find_all_subscribers.find { |s| s.instance_variable_get(:@delegate).class == self }
         end
 
         def self.find_all_subscribers
@@ -26,11 +26,11 @@ module NewRelic
           instance_variable_names.each do |name|
             if notifier.instance_variable_defined?(name)
               subscribers = notifier.instance_variable_get(name)
-              if subscribers.is_a? Array
+              if subscribers.is_a?(Array)
                 # Rails 5 @subscribers, and Rails 6 @other_subscribers is a
                 # plain array of subscriber objects
                 all_subscribers += subscribers
-              elsif subscribers.is_a? Hash
+              elsif subscribers.is_a?(Hash)
                 # Rails 6 @string_subscribers is a Hash mapping the pattern
                 # string of a subscriber to an array of subscriber objects
                 subscribers.values.each { |array| all_subscribers += array }
@@ -55,7 +55,7 @@ module NewRelic
         end
 
         def push_segment(id, segment)
-          segment_stack[id].push segment
+          segment_stack[id].push(segment)
         end
 
         def pop_segment(id)
@@ -64,7 +64,7 @@ module NewRelic
         end
 
         def segment_stack
-          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
+          Thread.current[@queue_key] ||= Hash.new { |h, id| h[id] = [] }
         end
 
         def state
@@ -76,16 +76,18 @@ module NewRelic
           # defensive.
           return if defined?(exception_object)
           return unless defined?(::ActiveSupport::VERSION)
+
           if ::ActiveSupport::VERSION::STRING < "5.0.0"
             # Earlier versions of Rails did not add the exception itself to the
-            # payload asssessible via :exception_object, so we create a stand-in
+            # payload accessible via :exception_object, so we create a stand-in
             # error object from the given class name and message.
             # NOTE: no backtrace available this way, but we can notice the error
             # well enough to send the necessary info the UI requires to present it.
             def exception_object(payload)
               exception_class, message = payload[:exception]
               return nil unless exception_class
-              NewRelic::Agent::NoticibleError.new exception_class, message
+
+              NewRelic::Agent::NoticeableError.new(exception_class, message)
             end
           else
             def exception_object(payload)
@@ -94,7 +96,6 @@ module NewRelic
           end
         end
       end
-
     end
   end
 end

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

@@ -0,0 +1,38 @@
+# 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 PadrinoTracer
+        module Chain
+          def self.instrument!
+            ::Padrino::Routing::InstanceMethods.module_eval do
+              include NewRelic::Agent::Instrumentation::Sinatra
+
+              def dispatch_with_newrelic
+                dispatch_with_tracing { dispatch_without_newrelic }
+              end
+
+              alias dispatch_without_newrelic dispatch!
+              alias dispatch! dispatch_with_newrelic
+
+              # Padrino 0.13 mustermann routing
+              if private_method_defined?(:invoke_route)
+                include NewRelic::Agent::Instrumentation::Padrino
+
+                def invoke_route_with_newrelic(*args, &block)
+                  invoke_route_with_tracing(*args) { invoke_route_without_newrelic(*args, &block) }
+                end
+
+                alias invoke_route_without_newrelic invoke_route
+                alias invoke_route invoke_route_with_newrelic
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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 Padrino
+    def invoke_route_with_tracing(*args)
+      begin
+        env["newrelic.last_route"] = args[0].original_path
+      rescue => e
+        ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
+      end
+
+      begin
+        txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
+        unless txn_name.nil?
+          ::NewRelic::Agent::Transaction.set_default_transaction_name(
+            "#{self.class.name}/#{txn_name}", :sinatra
+          )
+        end
+      rescue => e
+        ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
+      end
+
+      yield
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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 PadrinoTracer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Sinatra
+      include NewRelic::Agent::Instrumentation::Padrino
+
+      def dispatch
+        dispatch_with_tracing { super }
+      end
+
+      def invoke_route(*args, &block)
+        invoke_route_with_tracing(*args) { super }
+      end
+    end
+  end
+end

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

@@ -1,70 +1,32 @@
-# encoding: utf-8
 # 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
 
-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
-
-      # Padrino 0.13 mustermann routing
-      if private_method_defined?(:invoke_route)
-        include NewRelic::Agent::Instrumentation::Padrino
-
-        alias invoke_route_without_newrelic invoke_route
-        alias invoke_route invoke_route_with_newrelic
-      end
-    end
-  end
-end
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Padrino
-
-        def invoke_route_with_newrelic(*args, &block)
-          begin
-            env["newrelic.last_route"] = args[0].original_path
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
-          end
-
-          begin
-            txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
-            unless txn_name.nil?
-              ::NewRelic::Agent::Transaction.set_default_transaction_name(
-                "#{self.class.name}/#{txn_name}", :sinatra)
-            end
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
-          end
-
-          invoke_route_without_newrelic(*args, &block)
-        end
-
-      end
+    ::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,6 +1,6 @@
-# encoding: utf-8
 # 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
 
 DependencyDetection.defer do
   @name = :passenger
@@ -10,10 +10,10 @@ DependencyDetection.defer do
   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."
+      ::NewRelic::Agent.logger.debug("Passenger stopping this process, shutdown the agent.")
       NewRelic::Agent.instance.shutdown
     end
 

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
@@ -9,13 +9,12 @@ module NewRelic
       # Record queue time metrics based on any of three headers
       # which can be set on the request.
       module QueueTime
-        REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'.freeze
-        QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'.freeze
+        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)
+        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800).to_f
 
         CANDIDATE_HEADERS = [
           REQUEST_START_HEADER,
@@ -27,7 +26,7 @@ module NewRelic
 
         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|
@@ -40,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
 
@@ -52,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,75 @@
+# 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
+        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?
+
+          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?
+
+          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