newrelic_rpm 6.15.0 → 7.2.0

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

@@ -0,0 +1,34 @@
+# 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.
+
+module NewRelic::Agent::Instrumentation
+  module Padrino
+    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

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

@@ -0,0 +1,27 @@
+# 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.
+
+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 @@
+# 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.
+
+module NewRelic::Agent::Instrumentation
+  module Padrino
+    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/rack.rb

@@ -4,134 +4,10 @@
 
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
-module NewRelic
-  module Agent
-    module 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)
-          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
-
-        def self.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
-
-        def self.instrument_builder builder_class
-          ::NewRelic::Agent.logger.info "Installing deferred #{builder_class} instrumentation"
-
-          builder_class.class_eval do
-            class << self
-              attr_accessor :_nr_deferred_detection_ran
-            end
-            self._nr_deferred_detection_ran = false
-
-            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 #{builder_class} 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
-
-          def self.instrument_url_map 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
-
-      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)
-          return if middleware_class.nil?
-          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 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
-
-          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
-    end
-  end
-end
+require_relative 'rack/helpers'
+require_relative 'rack/instrumentation'
+require_relative 'rack/chain'
+require_relative 'rack/prepend'
 
 DependencyDetection.defer do
   named :rack
@@ -141,20 +17,27 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_builder ::Rack::Builder
+    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 :puma_rack
 
   depends_on do
-    defined?(::Puma::Rack::Builder) && !NewRelic::Agent.config[:disable_puma_rack]
+    defined?(::Puma::Rack::Builder)
   end
 
   executes do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_builder ::Puma::Rack::Builder
+    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
 
@@ -166,12 +49,16 @@ DependencyDetection.defer do
   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
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map ::Rack::URLMap
+    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
 
@@ -179,15 +66,18 @@ DependencyDetection.defer do
   named :puma_rack_urlmap
 
   depends_on do
-    defined? Puma::Rack::URLMap
+    defined?(Puma::Rack::URLMap)
   end
 
   depends_on do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled? &&
-      !::NewRelic::Agent.config[:disable_puma_rack]
+    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
   end
 
   executes do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map ::Puma::Rack::URLMap
+    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

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

@@ -0,0 +1,58 @@
+# 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.
+
+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, *args)
+              run_with_tracing(app) { |wrapped_app| run_without_newrelic(wrapped_app, *args) }
+            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,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.
+
+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)
+      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,73 @@
+# 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.
+
+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