newrelic_rpm 6.15.0 → 8.13.1

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

@@ -1,137 +1,13 @@
-# 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/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/rails3/action_controller.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
 
 require 'new_relic/agent/parameter_filtering'
 
@@ -20,17 +20,16 @@ module NewRelic
             end
           end
 
-          def process_action(*args) #THREAD_LOCAL_ACCESS
+          def process_action(*args) # THREAD_LOCAL_ACCESS
             munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(request.filtered_parameters)
             perform_action_with_newrelic_trace(:category => :controller,
-                                               :name => self.action_name,
-                                               :path => newrelic_metric_path,
-                                               :params => munged_params,
-                                               :class_name => self.class.name)  do
+              :name => self.action_name,
+              :path => newrelic_metric_path,
+              :params => munged_params,
+              :class_name => self.class.name) do
               super
             end
           end
-
         end
 
         module ActionView
@@ -41,12 +40,13 @@ module NewRelic
                 "file"
               elsif identifier.nil?
                 ::NewRelic::Agent::UNKNOWN_METRIC
-              elsif identifier.include? '/' # this is a filepath
+              elsif identifier.include?('/') # this is a filepath
                 identifier.split('/')[-2..-1].join('/')
               else
                 identifier
               end
             end
+
             def render_type(file_path)
               file = File.basename(file_path)
               if file.starts_with?('_')
@@ -74,7 +74,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 3 Controller instrumentation'
+    ::NewRelic::Agent.logger.info('Installing Rails 3 Controller instrumentation')
   end
 
   executes do
@@ -84,52 +84,16 @@ DependencyDetection.defer do
     end
   end
 end
-DependencyDetection.defer do
-  @name = :rails30_view
-
-  depends_on do
-    defined?(::Rails::VERSION::MAJOR) && defined?(::Rails::VERSION::MINOR) &&
-      ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 0
-  end
-
-  depends_on do
-    !NewRelic::Agent.config[:disable_view_instrumentation]
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 3.0 view instrumentation'
-  end
-
-  executes do
-    ActionView::Template.class_eval do
-      include NewRelic::Agent::MethodTracer
-      def render_with_newrelic(*args, &block)
-        options = if @virtual_path && @virtual_path.starts_with?('/') # file render
-          {:file => true }
-        else
-          {}
-        end
-        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(@identifier, options)}/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.render_type(@identifier)}"
-        trace_execution_scoped str do
-          render_without_newrelic(*args, &block)
-        end
-      end
-
-      alias_method :render_without_newrelic, :render
-      alias_method :render, :render_with_newrelic
-
-    end
-  end
-end
 
+# Though this uses the name :rails31_view, it is used only for rails 3.2 now
+# Rails 3.1 is no longer supported by the agent.
 DependencyDetection.defer do
   @name = :rails31_view
 
-  # We can't be sure that this will work with future versions of Rails 3.
-  # Currently enabled for Rails 3.1 and 3.2
+  # Enabled for Rails 3.2
   depends_on do
     defined?(::Rails::VERSION::MAJOR) && defined?(::Rails::VERSION::MINOR) &&
-      ::Rails::VERSION::MAJOR.to_i == 3 && ([1,2].member?(::Rails::VERSION::MINOR.to_i))
+      ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 2
   end
 
   depends_on do
@@ -137,7 +101,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 3.1/3.2 view instrumentation'
+    ::NewRelic::Agent.logger.info('Installing Rails 3.2 view instrumentation')
   end
 
   executes do
@@ -147,10 +111,10 @@ DependencyDetection.defer do
 
       def render_with_newrelic(context, options)
         # This is needed for rails 3.2 compatibility
-        @details = extract_details(options) if respond_to? :extract_details, true
+        @details = extract_details(options) if respond_to?(:extract_details, true)
         identifier = determine_template(options) ? determine_template(options).identifier : nil
         scope_name = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier, options)}/Rendering"
-        trace_execution_scoped scope_name do
+        trace_execution_scoped(scope_name) do
           render_without_newrelic(context, options)
         end
       end

data/lib/new_relic/agent/instrumentation/rails_middleware.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
 
 require 'new_relic/agent/instrumentation/middleware_proxy'
 

data/lib/new_relic/agent/instrumentation/rails_notifications/action_cable.rb

@@ -1,6 +1,7 @@
-# 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/action_cable_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
@@ -9,8 +10,8 @@ DependencyDetection.defer do
 
   depends_on do
     defined?(::Rails::VERSION::MAJOR) &&
-     ::Rails::VERSION::MAJOR.to_i >= 5 &&
-       defined?(::ActionCable)
+      ::Rails::VERSION::MAJOR.to_i >= 5 &&
+      defined?(::ActionCable)
   end
 
   depends_on do
@@ -19,7 +20,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing notifications based Action Cable instrumentation'
+    ::NewRelic::Agent.logger.info('Installing notifications based Action Cable instrumentation')
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb

@@ -1,10 +1,10 @@
-# 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/action_controller_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
-
 DependencyDetection.defer do
   @name = :action_controller_notifications
 
@@ -17,7 +17,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing notifications based Action Controller instrumentation'
+    ::NewRelic::Agent.logger.info('Installing notifications based Action Controller instrumentation')
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rails_notifications/action_view.rb

@@ -1,6 +1,7 @@
-# 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/action_view_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
@@ -17,7 +18,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing notification based Action View instrumentation'
+    NewRelic::Agent.logger.info('Installing notification based Action View instrumentation')
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rainbows_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 = :rainbows
@@ -10,8 +10,18 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rainbows instrumentation'
-    ::NewRelic::Agent.logger.info 'Detected Rainbows, please see additional documentation: https://newrelic.com/docs/troubleshooting/im-using-unicorn-and-i-dont-see-any-data'
+    ::NewRelic::Agent.logger.info('Installing Rainbows instrumentation')
+    ::NewRelic::Agent.logger.info('Detected Rainbows, please see additional documentation: https://newrelic.com/docs/troubleshooting/im-using-unicorn-and-i-dont-see-any-data')
+
+    deprecation_msg = 'The dispatcher rainbows is deprecated. It will be removed ' \
+     'in version 9.0.0. Please use a supported dispatcher instead. ' \
+     'Visit https://docs.newrelic.com/docs/apm/agents/ruby-agent/getting-started/ruby-agent-requirements-supported-frameworks for options.'
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_rainbows_dispatcher,
+      deprecation_msg
+    )
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rake/chain.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 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,149 @@
+# 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.
+            # No code coverage, as the strategy for mocking Kernel.exit prevents
+            # the at_exit block from being executed, and not mocking results in
+            # an early unwanted exit of MiniTest.
+            # :nocov:
+            NewRelic::Agent.shutdown
+            # :nocov:
+          end
+
+          @installed_at_exit = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# 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 Rake
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Rake::Tracer
+      def invoke(*args)
+        invoke_with_newrelic_tracing(*args) { super }
+      end
+    end
+  end
+end