newrelic_rpm 6.15.0 → 7.0.0

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

@@ -0,0 +1,57 @@
+# 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
+    
+            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

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

@@ -0,0 +1,36 @@
+# 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 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, *args)
+        run_with_tracing(app) { |wrapped_app| super(wrapped_app, *args) }
+      end
+
+      def use(middleware_class, *args, &blk)
+        use_with_tracing(middleware_class) { |wrapped_class| super(wrapped_class, *args, &blk) }
+      end
+    end
+  end
+end

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

@@ -2,17 +2,19 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
+require_relative 'rake/instrumentation'
+require_relative 'rake/chain'
+require_relative 'rake/prepend'
+
 DependencyDetection.defer do
   # Why not :rake? newrelic-rake used that name, so avoid conflicting
   named :rake_instrumentation
+  configure_with :rake
 
-  depends_on do
-    defined?(::Rake) &&
-      defined?(::Rake::VERSION) &&
-      ::NewRelic::Agent.config[:'disable_rake'] == false &&
-      ::NewRelic::Agent.config[:'rake.tasks'].any? &&
-      ::NewRelic::Agent::Instrumentation::RakeInstrumentation.should_install?
-  end
+  depends_on { defined?(::Rake) && defined?(::Rake::VERSION) }
+  depends_on { Gem::Version.new(::Rake::VERSION) >= Gem::Version.new("10.0.0") }
+  depends_on { ::NewRelic::Agent.config[:'rake.tasks'].any? }
+  depends_on { ::NewRelic::Agent::Instrumentation::Rake.safe_from_third_party_gem? }
 
   executes do
     ::NewRelic::Agent.logger.info  "Installing Rake instrumentation"
@@ -20,153 +22,10 @@ DependencyDetection.defer do
   end
 
   executes do
-    module Rake
-      class Task
-        alias_method :invoke_without_newrelic, :invoke
-
-        def invoke(*args)
-          unless NewRelic::Agent::Instrumentation::RakeInstrumentation.should_trace? name
-            return invoke_without_newrelic(*args)
-          end
-
-          begin
-            timeout = NewRelic::Agent.config[:'rake.connect_timeout']
-            NewRelic::Agent.instance.wait_on_connect(timeout)
-          rescue => e
-            NewRelic::Agent.logger.error("Exception in wait_on_connect", e)
-            return invoke_without_newrelic(*args)
-          end
-
-          NewRelic::Agent::Instrumentation::RakeInstrumentation.before_invoke_transaction(self)
-
-          NewRelic::Agent::Tracer.in_transaction(name: "OtherTransaction/Rake/invoke/#{name}", category: :rake) do
-            NewRelic::Agent::Instrumentation::RakeInstrumentation.record_attributes(args, self)
-            invoke_without_newrelic(*args)
-          end
-        end
-      end
-    end
-  end
-end
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module RakeInstrumentation
-        def self.should_install?
-          is_supported_version? && safe_from_third_party_gem?
-        end
-
-        def self.is_supported_version?
-          Gem::Version.new(::Rake::VERSION) >= Gem::Version.new("10.0.0")
-        end
-
-        def self.safe_from_third_party_gem?
-          if NewRelic::LanguageSupport.bundled_gem?("newrelic-rake")
-            ::NewRelic::Agent.logger.info("Not installing New Relic supported Rake instrumentation because the third party newrelic-rake gem is present")
-            false
-          else
-            true
-          end
-        end
-
-        def self.should_trace?(name)
-          NewRelic::Agent.config[:'rake.tasks'].any? do |regex|
-            regex.match(name)
-          end
-        end
-
-        def self.instrument_execute_on_prereqs(task)
-          task.prerequisite_tasks.each do |child_task|
-            instrument_execute(child_task)
-          end
-        end
-
-        def self.instrument_execute(task)
-          return if task.instance_variable_get(:@__newrelic_instrumented_execute)
-
-          task.instance_variable_set(:@__newrelic_instrumented_execute, true)
-          task.instance_eval do
-            def execute(*args, &block)
-              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
-                super
-              end
-            end
-          end
-
-          instrument_execute_on_prereqs(task)
-        end
-
-        def self.instrument_invoke_prerequisites_concurrently(task)
-          task.instance_eval do
-            def invoke_prerequisites_concurrently(*_)
-              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/multitask") do
-                prereqs = self.prerequisite_tasks.map(&:name).join(", ")
-                if txn = ::NewRelic::Agent::Tracer.current_transaction
-                  txn.current_segment.params[:statement] = NewRelic::Agent::Database.truncate_query("Couldn't trace concurrent prereq tasks: #{prereqs}")
-                end
-                super
-              end
-            end
-          end
-        end
-
-        def self.before_invoke_transaction(task)
-          ensure_at_exit
-
-          # We can't represent overlapping operations yet, so if multitask just
-          # make one node and annotate with prereq task names
-          if task.application.options.always_multitask
-            instrument_invoke_prerequisites_concurrently(task)
-          else
-            instrument_execute_on_prereqs(task)
-          end
-        rescue => e
-          NewRelic::Agent.logger.error("Error during Rake task invoke", e)
-        end
-
-        def self.record_attributes(args, task)
-          command_line = task.application.top_level_tasks.join(" ")
-          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes({ :command => command_line },
-                                                                        :'job.rake',
-                                                                        NewRelic::Agent::AttributeFilter::DST_NONE)
-          named_args = name_the_args(args, task.arg_names)
-          unless named_args.empty?
-            NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(named_args,
-                                                                          :'job.rake.args',
-                                                                          NewRelic::Agent::AttributeFilter::DST_NONE)
-          end
-        rescue => e
-          NewRelic::Agent.logger.error("Error during Rake task attribute recording.", e)
-        end
-
-        # Expects literal args passed to the task and array of task names
-        # If names are present without matching args, still sets them with nils
-        def self.name_the_args(args, names)
-          unfulfilled_names_length = names.length - args.length
-          if unfulfilled_names_length > 0
-            args.concat(Array.new(unfulfilled_names_length))
-          end
-
-          result = {}
-          args.zip(names).each_with_index do |(value, key), index|
-            result[key || index.to_s] = value
-          end
-          result
-        end
-
-        def self.ensure_at_exit
-          return if @installed_at_exit
-
-          at_exit do
-            # The agent's default at_exit might not default to installing, but
-            # if we are running an instrumented rake task, we always want it.
-            NewRelic::Agent.shutdown
-          end
-
-          @installed_at_exit = true
-        end
-      end
+    if use_prepend?
+      prepend_instrument ::Rake::Task, NewRelic::Agent::Instrumentation::Rake::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Rake::Chain
     end
   end
 end

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

@@ -0,0 +1,25 @@
+# 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 Rake
+    module Chain
+      def self.instrument!
+        ::Rake::Task.class_eval do
+          include NewRelic::Agent::Instrumentation::Rake::Tracer
+          alias_method :invoke_without_newrelic, :invoke
+
+          def invoke(*args)
+            invoke_with_newrelic_tracing(*args) { invoke_without_newrelic(*args) }
+          end
+        end
+      end
+    end
+  end
+end
+
+
+
+
+

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

@@ -0,0 +1,144 @@
+# 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
+    module Instrumentation
+      module Rake
+        module Tracer
+          def invoke_with_newrelic_tracing(*args)
+            unless NewRelic::Agent::Instrumentation::Rake.should_trace? name
+              return yield
+            end
+
+            begin
+              timeout = NewRelic::Agent.config[:'rake.connect_timeout']
+              NewRelic::Agent.instance.wait_on_connect(timeout)
+            rescue => e
+              NewRelic::Agent.logger.error("Exception in wait_on_connect", e)
+              return yield
+            end
+
+            NewRelic::Agent::Instrumentation::Rake.before_invoke_transaction(self)
+
+            NewRelic::Agent::Tracer.in_transaction(name: "OtherTransaction/Rake/invoke/#{name}", category: :rake) do
+              NewRelic::Agent::Instrumentation::Rake.record_attributes(args, self)
+              yield
+            end
+          end
+        end
+
+        module_function
+
+        def should_install?
+          safe_from_third_party_gem?
+        end
+
+        def safe_from_third_party_gem?
+          return true unless NewRelic::LanguageSupport.bundled_gem?("newrelic-rake")
+          ::NewRelic::Agent.logger.info("Not installing New Relic supported Rake instrumentation because the third party newrelic-rake gem is present")
+          false
+        end
+
+        def should_trace?(name)
+          NewRelic::Agent.config[:'rake.tasks'].any? do |regex|
+            regex.match(name)
+          end
+        end
+
+        def instrument_execute_on_prereqs(task)
+          task.prerequisite_tasks.each do |child_task|
+            instrument_execute(child_task)
+          end
+        end
+
+        def instrument_execute(task)
+          return if task.instance_variable_get(:@__newrelic_instrumented_execute)
+
+          task.instance_variable_set(:@__newrelic_instrumented_execute, true)
+          task.instance_eval do
+            def execute(*args, &block)
+              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
+                super
+              end
+            end
+          end
+
+          instrument_execute_on_prereqs(task)
+        end
+
+        def instrument_invoke_prerequisites_concurrently(task)
+          task.instance_eval do
+            def invoke_prerequisites_concurrently(*_)
+              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/multitask") do
+                prereqs = self.prerequisite_tasks.map(&:name).join(", ")
+                if txn = ::NewRelic::Agent::Tracer.current_transaction
+                  txn.current_segment.params[:statement] = NewRelic::Agent::Database.truncate_query("Couldn't trace concurrent prereq tasks: #{prereqs}")
+                end
+                super
+              end
+            end
+          end
+        end
+
+        def before_invoke_transaction(task)
+          ensure_at_exit
+
+          # We can't represent overlapping operations yet, so if multitask just
+          # make one node and annotate with prereq task names
+          if task.application.options.always_multitask
+            instrument_invoke_prerequisites_concurrently(task)
+          else
+            instrument_execute_on_prereqs(task)
+          end
+        rescue => e
+          NewRelic::Agent.logger.error("Error during Rake task invoke", e)
+        end
+
+        def record_attributes(args, task)
+          command_line = task.application.top_level_tasks.join(" ")
+          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes({ :command => command_line },
+                                                                        :'job.rake',
+                                                                        NewRelic::Agent::AttributeFilter::DST_NONE)
+          named_args = name_the_args(args, task.arg_names)
+          unless named_args.empty?
+            NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(named_args,
+                                                                          :'job.rake.args',
+                                                                          NewRelic::Agent::AttributeFilter::DST_NONE)
+          end
+        rescue => e
+          NewRelic::Agent.logger.error("Error during Rake task attribute recording.", e)
+        end
+
+        # Expects literal args passed to the task and array of task names
+        # If names are present without matching args, still sets them with nils
+        def name_the_args(args, names)
+          unfulfilled_names_length = names.length - args.length
+          if unfulfilled_names_length > 0
+            args.concat(Array.new(unfulfilled_names_length))
+          end
+
+          result = {}
+          args.zip(names).each_with_index do |(value, key), index|
+            result[key || index.to_s] = value
+          end
+          result
+        end
+
+        def ensure_at_exit
+          return if @installed_at_exit
+
+          at_exit do
+            # The agent's default at_exit might not default to installing, but
+            # if we are running an instrumented rake task, we always want it.
+            NewRelic::Agent.shutdown
+          end
+
+          @installed_at_exit = true
+        end
+      end
+    end
+  end
+end