newrelic_rpm 8.15.0 → 9.6.0

data/lib/new_relic/control/frameworks/rails.rb

@@ -10,6 +10,9 @@ module NewRelic
       # Rails specific configuration, instrumentation, environment values,
       # etc.
       class Rails < NewRelic::Control::Frameworks::Ruby
+        BROWSER_MONITORING_INSTALLED_SINGLETON = NewRelic::Agent.config
+        BROWSER_MONITORING_INSTALLED_VARIABLE = :@browser_monitoring_installed
+
         def env
           @env ||= (ENV['NEW_RELIC_ENV'] || RAILS_ENV.dup)
         end
@@ -44,26 +47,38 @@ module NewRelic
         # find a config and use that.
         def init_config(options = {})
           @config = options[:config]
-          # Install the dependency detection,
-          if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
-            rails_config.after_initialize do
-              # This will insure we load all the instrumentation as late as possible.  If the agent
-              # is not enabled, it will load a limited amount of instrumentation.
-              DependencyDetection.detect!
-            end
+          install_dependency_detection
+          install_browser_monitoring_and_agent_hooks
+        rescue => e
+          ::NewRelic::Agent.logger.error('Failure during init_config for Rails. Is Rails required in a non-Rails ' \
+                                         'app? Set NEW_RELIC_FRAMEWORK=ruby to avoid this message. The Ruby agent ' \
+                                         'will continue running, but Rails-specific features may be missing. ' \
+                                         "#{e.class} - #{e.message}")
+        end
+
+        def install_dependency_detection
+          return unless rails_config && ::Rails.configuration.respond_to?(:after_initialize)
+
+          rails_config.after_initialize do
+            # This will insure we load all the instrumentation as late as
+            # possible. If the agent is not enabled, it will load a limited
+            # amount of instrumentation.
+            DependencyDetection.detect!
           end
+        end
+
+        def install_browser_monitoring_and_agent_hooks
+          return unless rails_config
+
           if !Agent.config[:agent_enabled]
-            # Might not be running if it does not think mongrel, thin, passenger, etc
-            # is running, if it thinks it's a rake task, or if the agent_enabled is false.
-            ::NewRelic::Agent.logger.info("New Relic Agent not running.")
+            # Might not be running if it does not think mongrel, thin,
+            # passenger, etc. is running, if it thinks it's a rake task, or
+            # if the agent_enabled is false.
+            ::NewRelic::Agent.logger.info('New Relic Agent not running. Skipping browser monitoring and agent hooks.')
           else
             install_browser_monitoring(rails_config)
             install_agent_hooks(rails_config)
           end
-        rescue => e
-          ::NewRelic::Agent.logger.error("Failure during init_config for Rails. Is Rails required in a non-Rails app? Set NEW_RELIC_FRAMEWORK=ruby to avoid this message.",
-            "The Ruby agent will continue running, but Rails-specific features may be missing.",
-            e)
         end
 
         def install_agent_hooks(config)
@@ -77,29 +92,38 @@ module NewRelic
             return unless NewRelic::Rack::AgentHooks.needed?
 
             config.middleware.use(NewRelic::Rack::AgentHooks)
-            ::NewRelic::Agent.logger.debug("Installed New Relic Agent Hooks middleware")
+            ::NewRelic::Agent.logger.debug('Installed New Relic Agent Hooks middleware')
           rescue => e
-            ::NewRelic::Agent.logger.warn("Error installing New Relic Agent Hooks middleware", e)
+            ::NewRelic::Agent.logger.warn('Error installing New Relic Agent Hooks middleware', e)
           end
         end
 
         def install_browser_monitoring(config)
           @install_lock.synchronize do
-            return if defined?(@browser_monitoring_installed) && @browser_monitoring_installed
+            return if browser_agent_already_installed?
 
-            @browser_monitoring_installed = true
+            mark_browser_agent_as_installed
             return if config.nil? || !config.respond_to?(:middleware) || !Agent.config[:'browser_monitoring.auto_instrument']
 
             begin
               require 'new_relic/rack/browser_monitoring'
               config.middleware.use(NewRelic::Rack::BrowserMonitoring)
-              ::NewRelic::Agent.logger.debug("Installed New Relic Browser Monitoring middleware")
+              ::NewRelic::Agent.logger.debug('Installed New Relic Browser Monitoring middleware')
             rescue => e
-              ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware", e)
+              ::NewRelic::Agent.logger.warn('Error installing New Relic Browser Monitoring middleware', e)
             end
           end
         end
 
+        def browser_agent_already_installed?
+          BROWSER_MONITORING_INSTALLED_SINGLETON.instance_variable_defined?(BROWSER_MONITORING_INSTALLED_VARIABLE) &&
+            BROWSER_MONITORING_INSTALLED_SINGLETON.instance_variable_get(BROWSER_MONITORING_INSTALLED_VARIABLE)
+        end
+
+        def mark_browser_agent_as_installed
+          BROWSER_MONITORING_INSTALLED_SINGLETON.instance_variable_set(BROWSER_MONITORING_INSTALLED_VARIABLE, true)
+        end
+
         def rails_version
           @rails_version ||= Gem::Version.new(::Rails::VERSION::STRING)
         end

data/lib/new_relic/control/frameworks/roda.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
+
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Roda
+      class Roda < NewRelic::Control::Frameworks::Ruby
+        protected
+
+        def install_shim
+          super
+          ::Roda.class_eval { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/control/instance_methods.rb

@@ -65,7 +65,7 @@ module NewRelic
         # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
         # methods in the module methods.
         # Rails applications load the next two lines before any other initializers are run
-        unless defined?(Rails::VERSION) && NewRelic::Agent.config[:defer_rails_initialization]
+        unless defined?(Rails::VERSION) && ENV['NEW_RELIC_DEFER_RAILS_INITIALIZATION']
           Module.send(:include, NewRelic::Agent::MethodTracer::ClassMethods)
           Module.send(:include, NewRelic::Agent::MethodTracer)
         end
@@ -82,10 +82,10 @@ module NewRelic
         if @started_in_env && @started_in_env != env
           Agent.logger.error("Attempted to start agent in #{env.inspect} environment, but agent was already running " \
             "in #{@started_in_env.inspect}", "The agent will continue running in #{@started_in_env.inspect}. To " \
-            "alter this, ensure the desired environment is set before the agent starts.")
+            'alter this, ensure the desired environment is set before the agent starts.')
         else
           Agent.logger.info("Starting the New Relic agent version #{NewRelic::VERSION::STRING} in #{env.inspect} " \
-            "environment.", "To prevent agent startup add a NEW_RELIC_AGENT_ENABLED=false environment variable or " \
+            'environment.', 'To prevent agent startup add a NEW_RELIC_AGENT_ENABLED=false environment variable or ' \
             "modify the #{env.inspect} section of your newrelic.yml.")
         end
 
@@ -106,9 +106,9 @@ module NewRelic
       end
 
       def handle_invalid_security_settings
-        NewRelic::Agent.logger.error("Security Policies and High Security Mode cannot both be present in the agent " \
-          "configuration. If Security Policies have been set for your account, please ensure the " \
-          "security_policies_token is set but high_security is disabled (default).")
+        NewRelic::Agent.logger.error('Security Policies and High Security Mode cannot both be present in the agent ' \
+          'configuration. If Security Policies have been set for your account, please ensure the ' \
+          'security_policies_token is set but high_security is disabled (default).')
         install_shim
       end
 

data/lib/new_relic/control/instrumentation.rb

@@ -62,9 +62,8 @@ module NewRelic
           File.join(instrumentation_path, app.to_s, '*.rb')
         @instrumentation_files.each { |pattern| load_instrumentation_files(pattern) }
         DependencyDetection.detect!
-        ruby_deprecation
         rails_32_deprecation
-        ::NewRelic::Agent.logger.info("Finished instrumentation")
+        ::NewRelic::Agent.logger.info('Finished instrumentation')
       end
     end
 
@@ -81,19 +80,6 @@ module NewRelic
       )
     end
 
-    def ruby_deprecation
-      return unless RUBY_VERSION < '2.4.0'
-
-      deprecation_msg = 'The Ruby Agent is dropping support for Rubies below 2.4 ' \
-        'in version 9.0.0. Please upgrade your Ruby version to continue receiving support. ' \
-
-      ::NewRelic::Agent.logger.log_once(
-        :warn,
-        :deprecated_ruby_version,
-        deprecation_msg
-      )
-    end
-
     include Instrumentation
   end
 end

data/lib/new_relic/control/private_instance_methods.rb

@@ -12,7 +12,7 @@ module NewRelic
 
       def configure_high_security
         if security_settings_valid? && Agent.config[:high_security]
-          Agent.logger.info("Installing high security configuration based on local configuration")
+          Agent.logger.info('Installing high security configuration based on local configuration')
           Agent.config.replace_or_add_config(Agent::Configuration::HighSecuritySource.new(Agent.config))
         end
       end

data/lib/new_relic/dependency_detection.rb

@@ -27,6 +27,8 @@ module DependencyDetection
     @items.each do |item|
       if item.dependencies_satisfied?
         item.execute
+      else
+        item.configure_as_unsatisfied unless item.disabled_configured?
       end
     end
   end
@@ -35,19 +37,6 @@ module DependencyDetection
     @items.find { |i| i.name == name }
   end
 
-  def installed?(name)
-    item = dependency_by_name(name)
-    item && item.executed
-  end
-
-  def items
-    @items
-  end
-
-  def items=(new_items)
-    @items = new_items
-  end
-
   class Dependent
     attr_reader :executed
     attr_accessor :name
@@ -75,6 +64,10 @@ module DependencyDetection
       !executed and check_dependencies
     end
 
+    def configure_as_unsatisfied
+      NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = :unsatisfied
+    end
+
     def source_location_for(klass, method_name)
       Object.instance_method(:method).bind(klass.allocate).call(method_name).source_location.to_s
     end
@@ -83,7 +76,7 @@ module DependencyDetection
     # Given "NewRelic::Agent::Instrumentation::NetHTTP::Prepend"
     # Will extract "NetHTTP" which is in the 2nd to last spot
     def extract_supportability_name(instrumenting_module)
-      instrumenting_module.to_s.split("::")[-2]
+      instrumenting_module.to_s.split('::')[-2]
     end
 
     def log_and_instrument(method, instrumenting_module, supportability_name)
@@ -94,20 +87,20 @@ module DependencyDetection
     end
 
     def prepend_instrument(target_class, instrumenting_module, supportability_name = nil)
-      log_and_instrument("Prepend", instrumenting_module, supportability_name) do
+      log_and_instrument('Prepend', instrumenting_module, supportability_name) do
         target_class.send(:prepend, instrumenting_module)
       end
     end
 
     def chain_instrument(instrumenting_module, supportability_name = nil)
-      log_and_instrument("MethodChaining", instrumenting_module, supportability_name) do
+      log_and_instrument('MethodChaining', instrumenting_module, supportability_name) do
         instrumenting_module.instrument!
       end
     end
 
     def chain_instrument_target(target, instrumenting_module, supportability_name = nil)
       NewRelic::Agent.logger.info("Installing deferred #{target} instrumentation")
-      log_and_instrument("MethodChaining", instrumenting_module, supportability_name) do
+      log_and_instrument('MethodChaining', instrumenting_module, supportability_name) do
         instrumenting_module.instrument!(target)
       end
     end
@@ -192,6 +185,15 @@ module DependencyDetection
       return valid_value
     end
 
+    # update any :auto config value to be either :prepend or :chain after auto
+    # determination has selected one of those to use
+    def update_config_value(use_prepend)
+      if config_key && auto_configured?
+        NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = use_prepend ? :prepend : :chain
+      end
+      use_prepend
+    end
+
     def config_value
       return AUTO_CONFIG_VALUE unless config_key
 
@@ -215,7 +217,7 @@ module DependencyDetection
     end
 
     def use_prepend?
-      prepend_configured? || (auto_configured? && !prepend_conflicts?)
+      update_config_value(prepend_configured? || (auto_configured? && !prepend_conflicts?))
     end
 
     def prepend_conflicts?

data/lib/new_relic/environment_report.rb

@@ -52,7 +52,7 @@ module NewRelic
         # though so try it if the above fails.
         Bundler.load.specs.map do |spec|
           version = (spec.respond_to?(:version) && spec.version)
-          spec.name + (version ? "(#{version})" : "")
+          spec.name + (version ? "(#{version})" : '')
         end
       end
     end
@@ -118,19 +118,19 @@ module NewRelic
     def record_value(data, key, value)
       data[key] = value
 
-      Agent.record_metric("Supportability/EnvironmentReport/success", 0.0)
+      Agent.record_metric('Supportability/EnvironmentReport/success', 0.0)
       Agent.record_metric("Supportability/EnvironmentReport/success/#{key}", 0.0)
     end
 
     def record_empty_value(key, value)
       Agent.logger.debug("EnvironmentReport ignoring value for #{key.inspect} which came back falsey: #{value.inspect}")
-      Agent.record_metric("Supportability/EnvironmentReport/empty", 0.0)
+      Agent.record_metric('Supportability/EnvironmentReport/empty', 0.0)
       Agent.record_metric("Supportability/EnvironmentReport/empty/#{key}", 0.0)
     end
 
     def rescue_initialize(key, exception)
       Agent.logger.debug("EnvironmentReport failed to retrieve value for #{key.inspect}: #{exception}")
-      Agent.record_metric("Supportability/EnvironmentReport/error", 0.0)
+      Agent.record_metric('Supportability/EnvironmentReport/error', 0.0)
       Agent.record_metric("Supportability/EnvironmentReport/error/#{key}", 0.0)
     end
   end

data/lib/new_relic/helper.rb

@@ -63,7 +63,8 @@ module NewRelic
         raise NewRelic::CommandRunFailedError.new("Failed to run command '#{command}': #{message}")
       end
 
-      output.chomp if output
+      # needs else branch coverage
+      output.chomp if output # rubocop:disable Style/SafeNavigation
     end
 
     # TODO: Open3 defers the actual execution of a binary to Process.spawn,

data/lib/new_relic/language_support.rb

@@ -62,7 +62,7 @@ module NewRelic
           #
           # Can't help if the constant isn't a class...
           if result.is_a?(Module)
-            expected_name = "#{namespace}::#{name}".gsub(/^Object::/, "")
+            expected_name = "#{namespace}::#{name}".gsub(/^Object::/, '')
             return unless expected_name == result.to_s
           end
 
@@ -78,6 +78,15 @@ module NewRelic
       camelized.split(/\-|\_/).map(&:capitalize).join
     end
 
+    def camelize_with_first_letter_downcased(string)
+      camelized = camelize(string)
+      camelized[0].downcase.concat(camelized[1..-1])
+    end
+
+    def snakeize(string)
+      string.gsub(/(.)([A-Z])/, '\1_\2').downcase
+    end
+
     def bundled_gem?(gem_name)
       defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?(gem_name)
     rescue => e

data/lib/new_relic/latest_changes.rb

@@ -8,7 +8,7 @@ module NewRelic
       File.join(File.dirname(__FILE__), '..', '..', 'CHANGELOG.md')
     end
 
-    FOOTER = <<'EOS'
+    FOOTER = <<EOS
     See https://github.com/newrelic/newrelic-ruby-agent/blob/main/CHANGELOG.md for a full list of
     changes.
 EOS
@@ -26,12 +26,12 @@ EOS
     # * This is a patch item (3.7.1.188)
     def self.read_patch(patch_level, changelog = default_changelog)
       latest = extract_latest_changes(File.read(changelog))
-      changes = ["## v#{patch_level}", ""]
+      changes = ["## v#{patch_level}", '']
 
       current_item = nil
       latest.each do |line|
-        if line =~ /^\s*\*.*/
-          if line =~ /\(#{patch_level}\)/
+        if /^\s*\*.*/.match?(line)
+          if /\(#{patch_level}\)/.match?(line)
             # Found a patch level item, so start tracking the lines!
             current_item = line
           else
@@ -52,12 +52,12 @@ EOS
       changes = []
       version_count = 0
       contents.each_line do |line|
-        if line =~ /##\s+v[\d.]+/
+        if /##\s+v[\d.]+/.match?(line)
           version_count += 1
         end
         break if version_count >= 2
 
-        changes << line.sub(/^  \* /, "* ").chomp
+        changes << line.sub(/^  \* /, '* ').chomp
       end
       changes
     end

data/lib/new_relic/local_environment.rb

@@ -74,9 +74,7 @@ module NewRelic
         unicorn
         webrick
         fastcgi
-        rainbows
       ]
-      # TODO: MAJOR VERSION - remove rainbows
       while dispatchers.any? && @discovered_dispatcher.nil?
         send('check_for_' + (dispatchers.shift))
       end
@@ -134,14 +132,6 @@ module NewRelic
       end
     end
 
-    # TODO: MAJOR VERSION - remove this method
-    def check_for_rainbows
-      if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && NewRelic::LanguageSupport.object_space_usable?
-        v = find_class_in_object_space(::Rainbows::HttpServer)
-        @discovered_dispatcher = :rainbows if v
-      end
-    end
-
     def check_for_puma
       if defined?(::Puma) && File.basename($0) == 'puma'
         @discovered_dispatcher = :puma

data/lib/new_relic/noticed_error.rb

@@ -13,20 +13,22 @@ class NewRelic::NoticedError
   attr_accessor :path, :timestamp, :message, :exception_class_name,
     :request_uri, :request_port, :file_name, :line_number,
     :stack_trace, :attributes_from_notice_error, :attributes,
-    :expected
+    :expected, :transaction_id
 
-  attr_reader :exception_id, :is_internal
+  attr_reader :error_group, :exception_id, :is_internal
 
   STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE = "Message removed by New Relic 'strip_exception_messages' setting"
   UNKNOWN_ERROR_CLASS_NAME = 'Error'
   NIL_ERROR_MESSAGE = '<no message>'
 
-  USER_ATTRIBUTES = "userAttributes"
-  AGENT_ATTRIBUTES = "agentAttributes"
-  INTRINSIC_ATTRIBUTES = "intrinsics"
+  USER_ATTRIBUTES = 'userAttributes'
+  AGENT_ATTRIBUTES = 'agentAttributes'
+  INTRINSIC_ATTRIBUTES = 'intrinsics'
 
   DESTINATION = NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
 
+  AGENT_ATTRIBUTE_ERROR_GROUP = :'error.group.name'
+
   ERROR_PREFIX_KEY = 'error'
   ERROR_MESSAGE_KEY = "#{ERROR_PREFIX_KEY}.message"
   ERROR_CLASS_KEY = "#{ERROR_PREFIX_KEY}.class"
@@ -43,6 +45,7 @@ class NewRelic::NoticedError
     @is_internal = (exception.class < NewRelic::Agent::InternalAgentError)
 
     extract_class_name_and_message_from(exception)
+    @transaction_id = NewRelic::Agent::Tracer&.current_transaction&.guid
 
     # clamp long messages to 4k so that we don't send a lot of
     # overhead across the wire
@@ -77,11 +80,13 @@ class NewRelic::NoticedError
   include NewRelic::Coerce
 
   def to_collector_array(encoder = nil)
-    [NewRelic::Helper.time_to_millis(timestamp),
+    arr = [NewRelic::Helper.time_to_millis(timestamp),
       string(path),
       string(message),
       string(exception_class_name),
       processed_attributes]
+    arr << @transaction_id if @transaction_id
+    arr
   end
 
   # Note that we process attributes lazily and store the result. This is because
@@ -141,21 +146,9 @@ class NewRelic::NoticedError
   end
 
   def build_agent_attributes(merged_attributes)
-    agent_attributes = if @attributes
-      @attributes.agent_attributes_for(DESTINATION)
-    else
-      NewRelic::EMPTY_HASH
-    end
-
-    # It's possible to override the request_uri from the transaction attributes
-    # with a uri passed to notice_error. Add it to merged_attributes filter and
-    # merge with the transaction attributes, possibly overriding the request_uri
-    if request_uri
-      merged_attributes.add_agent_attribute(:'request.uri', request_uri, DESTINATION)
-      agent_attributes.merge(merged_attributes.agent_attributes_for(DESTINATION))
-    end
+    return NewRelic::EMPTY_HASH unless @attributes
 
-    agent_attributes
+    @attributes.agent_attributes_for(DESTINATION)
   end
 
   def build_intrinsic_attributes
@@ -197,4 +190,16 @@ class NewRelic::NoticedError
       @message = exception.to_s
     end
   end
+
+  def error_group=(name)
+    return if name.nil? || name.empty?
+
+    if agent_attributes.frozen?
+      processed_attributes[AGENT_ATTRIBUTES] = agent_attributes.merge(AGENT_ATTRIBUTE_ERROR_GROUP => name)
+    else
+      agent_attributes[AGENT_ATTRIBUTE_ERROR_GROUP] = name
+    end
+
+    @error_group = name
+  end
 end

data/lib/new_relic/rack/agent_hooks.rb

@@ -23,7 +23,7 @@ module NewRelic::Rack
   #
   class AgentHooks < AgentMiddleware
     def self.needed?
-      !NewRelic::Agent.config[:disable_middleware_instrumentation]
+      NewRelic::Agent.config[:disable_middleware_instrumentation]
     end
 
     def traced_call(env)

data/lib/new_relic/rack/agent_middleware.rb

@@ -26,22 +26,6 @@ module NewRelic
         prefix = ::NewRelic::Agent::Instrumentation::ControllerInstrumentation::TransactionNamer.prefix_for_category(nil, @category)
         "#{prefix}#{self.class.name}/call"
       end
-
-      # If middleware tracing is disabled, we'll still inject our agent-specific
-      # middlewares, and still trace those, but we don't want to capture HTTP
-      # response codes, since middleware that's outside of ours might change the
-      # response code before it goes back to the client.
-      def capture_http_response_code(state, result)
-        return if NewRelic::Agent.config[:disable_middleware_instrumentation]
-
-        super
-      end
-
-      def capture_response_content_type(state, result)
-        return if NewRelic::Agent.config[:disable_middleware_instrumentation]
-
-        super
-      end
     end
   end
 end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -26,11 +26,11 @@ module NewRelic
       ATTACHMENT = 'attachment'.freeze
       TEXT_HTML = 'text/html'.freeze
 
-      BODY_START = "<body".freeze
-      HEAD_START = "<head".freeze
-      GT = ">".freeze
+      BODY_START = '<body'.freeze
+      HEAD_START = '<head'.freeze
+      GT = '>'.freeze
 
-      ALREADY_INSTRUMENTED_KEY = "newrelic.browser_monitoring_already_instrumented"
+      ALREADY_INSTRUMENTED_KEY = 'newrelic.browser_monitoring_already_instrumented'
       CHARSET_RE = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
       X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
 
@@ -40,7 +40,7 @@ module NewRelic
 
         js_to_inject = NewRelic::Agent.browser_timing_header
         if (js_to_inject != NewRelic::EMPTY_STR) && should_instrument?(env, status, headers)
-          response_string = autoinstrument_source(response, headers, js_to_inject)
+          response_string = autoinstrument_source(response, js_to_inject)
           if headers.key?(CONTENT_LENGTH)
             content_length = response_string ? response_string.bytesize : 0
             headers[CONTENT_LENGTH] = content_length.to_s
@@ -69,11 +69,17 @@ module NewRelic
 
       private
 
-      def autoinstrument_source(response, headers, js_to_inject)
+      def autoinstrument_source(response, js_to_inject)
         source = gather_source(response)
         close_old_response(response)
-        return nil unless source
+        return unless source
 
+        modify_source(source, js_to_inject)
+      rescue => e
+        NewRelic::Agent.logger.debug("Skipping RUM instrumentation on exception: #{e.class} - #{e.message}")
+      end
+
+      def modify_source(source, js_to_inject)
         # Only scan the first 50k (roughly) then give up.
         beginning_of_source = source[0..SCAN_LIMIT]
         meta_tag_positions = find_meta_tag_positions(beginning_of_source)
@@ -81,26 +87,24 @@ module NewRelic
           if insertion_index = find_insertion_index(meta_tag_positions, beginning_of_source, body_start)
             source = source_injection(source, insertion_index, js_to_inject)
           else
-            NewRelic::Agent.logger.debug("Skipping RUM instrumentation. Could not properly determine location to inject script.")
+            NewRelic::Agent.logger.debug('Skipping RUM instrumentation. Could not properly determine location to ' \
+                                         'inject script.')
           end
         else
           msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
           NewRelic::Agent.logger.log_once(:warn, :rum_insertion_failure, msg)
           NewRelic::Agent.logger.debug(msg)
         end
-
         source
-      rescue => e
-        NewRelic::Agent.logger.debug("Skipping RUM instrumentation on exception.", e)
-        nil
       end
 
       def html?(headers)
-        headers[CONTENT_TYPE] && headers[CONTENT_TYPE].include?(TEXT_HTML)
+        # needs else branch coverage
+        headers[CONTENT_TYPE] && headers[CONTENT_TYPE].include?(TEXT_HTML) # rubocop:disable Style/SafeNavigation
       end
 
       def attachment?(headers)
-        headers[CONTENT_DISPOSITION] && headers[CONTENT_DISPOSITION].include?(ATTACHMENT)
+        headers[CONTENT_DISPOSITION]&.include?(ATTACHMENT)
       end
 
       def streaming?(env, headers)
@@ -139,7 +143,7 @@ module NewRelic
       end
 
       # Per "The Response > The Body" section of Rack spec, we should close
-      # if our response is able. http://rack.rubyforge.org/doc/SPEC.html
+      # if our response is able. https://github.com/rack/rack/blob/main/SPEC.rdoc
       def close_old_response(response)
         response.close if response.respond_to?(:close)
       end
@@ -150,12 +154,12 @@ module NewRelic
 
       def find_x_ua_compatible_position(beginning_of_source)
         match = X_UA_COMPATIBLE_RE.match(beginning_of_source)
-        match.end(0) if match
+        match&.end(0)
       end
 
       def find_charset_position(beginning_of_source)
         match = CHARSET_RE.match(beginning_of_source)
-        match.end(0) if match
+        match&.end(0)
       end
 
       def find_end_of_head_open(beginning_of_source)