newrelic_rpm 6.15.0 → 7.2.0

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

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

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -83,39 +83,44 @@ module NewRelic
         value.nil? || value.empty?
       end
 
-      def browser_timing_header #THREAD_LOCAL_ACCESS
+      def browser_timing_header(nonce=nil) #THREAD_LOCAL_ACCESS
         return '' unless js_enabled_and_ready? # fast exit
 
         state = NewRelic::Agent::Tracer.state
 
         return '' unless insert_js?(state) # slower exit
 
-        bt_config = browser_timing_config(state)
+        bt_config = browser_timing_config(state, nonce)
         return '' if bt_config.empty?
 
-        bt_config + browser_timing_loader
+        bt_config + browser_timing_loader(nonce)
       rescue => e
         ::NewRelic::Agent.logger.debug "Failure during RUM browser_timing_header construction", e
         ''
       end
 
-      def browser_timing_loader
-        html_safe_if_needed("\n<script>#{Agent.config[:js_agent_loader]}</script>")
+      def browser_timing_loader(nonce=nil)
+        html_safe_if_needed("\n<script type=\"text/javascript\"#{create_nonce(nonce)}>#{Agent.config[:js_agent_loader]}</script>")
       end
 
-      def browser_timing_config(state)
+      def browser_timing_config(state, nonce=nil)
         txn = state.current_transaction
         return '' if txn.nil?
 
         txn.freeze_name_and_execute_if_not_ignored do
           data = data_for_js_agent(txn)
           json = ::JSON.dump(data)
-          return html_safe_if_needed("\n<script>window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
+          return html_safe_if_needed("\n<script type=\"text/javascript\"#{create_nonce(nonce)}>window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
         end
 
         ''
       end
 
+      def create_nonce(nonce=nil)
+        return '' unless nonce
+        " nonce=\"#{nonce.to_s}\""
+      end
+
       BEACON_KEY           = "beacon".freeze
       ERROR_BEACON_KEY     = "errorBeacon".freeze
       LICENSE_KEY_KEY      = "licenseKey".freeze

data/lib/new_relic/agent/new_relic_service.rb

@@ -41,7 +41,6 @@ module NewRelic
         @configured_collector = collector
         @request_timeout = Agent.config[:timeout]
         @ssl_cert_store = nil
-        @use_bundled_certs = false
         @in_session = nil
         @agent_id = nil
         @shared_tcp_connection = nil
@@ -299,7 +298,7 @@ module NewRelic
       end
 
       def set_cert_store(conn)
-        if @use_bundled_certs || NewRelic::Agent.config[:ca_bundle_path]
+        if NewRelic::Agent.config[:ca_bundle_path]
           conn.cert_store  = ssl_cert_store
         else
           ::NewRelic::Agent.logger.debug("Using default security certificates")
@@ -348,13 +347,8 @@ module NewRelic
         start_connection(conn)
         conn
       rescue Timeout::Error
-        if @use_bundled_certs == false
-          ::NewRelic::Agent.logger.info("Unable to connect. Falling back to bundled security certificates")
-          @use_bundled_certs = true
-          retry
-        else
-          raise
-        end
+        ::NewRelic::Agent.logger.info ("Timeout while attempting to connect. You may need to install system-level CA Certificates, as the ruby agent no longer includes these.")
+        raise
       end
 
       # The path to the certificate file used to verify the SSL
@@ -363,9 +357,6 @@ module NewRelic
         if path_override = NewRelic::Agent.config[:ca_bundle_path]
           NewRelic::Agent.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exist? path_override
           path_override
-        else
-          ::NewRelic::Agent.increment_metric("Supportability/Ruby/Certificate/BundleRequired")
-          File.expand_path(File.join(control.newrelic_root, 'cert', 'cacert.pem'))
         end
       end
 
@@ -435,7 +426,18 @@ module NewRelic
         size = data.size
 
         # Preconnect needs to always use the configured collector host, not the redirect host
-        endpoint_specific_collector = (method == :preconnect) ? @configured_collector : @collector
+        # endpoint_specific_collector = (method == :preconnect) ? @configured_collector : @collector
+
+        # This is a temporary workaround due to errors occurring on the staging collector. The prod collector does not have the same issue.
+        # The staging collector does not respond correctly when using the configured collector host for preconnect, so must use the redirect host
+        # Once this issue is resolved on the staging collector, use the original line that is commented out above.
+        endpoint_specific_collector = if method == :preconnect && (@configured_collector && @configured_collector.name != 'staging-collector.newrelic.com')
+                                        ::NewRelic::Agent.logger.debug "Using configured collector for preconnect: #{@configured_collector}"
+                                        @configured_collector
+                                      else
+                                        ::NewRelic::Agent.logger.debug "Using redirect host for collector: #{@collector}"
+                                        @collector
+                                      end
 
         uri = remote_method_uri(method)
         full_uri = "#{endpoint_specific_collector}#{uri}"

data/lib/new_relic/agent/sql_sampler.rb

@@ -65,7 +65,7 @@ module NewRelic
       end
 
       # This is called when we are done with the transaction.
-      def on_finishing_transaction(state, name, time=Time.now)
+      def on_finishing_transaction(state, name)
         return unless enabled?
 
         data = state.sql_sampler_transaction_data
@@ -359,10 +359,10 @@ module NewRelic
       # need to hash the same way in every process, to be able to aggregate slow SQL traces
       def consistent_hash(string)
         if NewRelic::Agent.config[:'slow_sql.use_longer_sql_id']
-          Digest::MD5.hexdigest(string).hex.modulo(2**63-1)
+          Digest::SHA1.hexdigest(string).hex.modulo(2**63-1)
         else
           # from when sql_id needed to fit in an INT(11)
-          Digest::MD5.hexdigest(string).hex.modulo(2**31-1)
+          Digest::SHA1.hexdigest(string).hex.modulo(2**31-1)
         end
       end
     end

data/lib/new_relic/agent/transaction.rb

@@ -464,7 +464,7 @@ module NewRelic
         @ignore_apdex = options[:ignore_apdex] if options.key? :ignore_apdex
         @ignore_enduser = options[:ignore_enduser] if options.key? :ignore_enduser
 
-        nest_initial_segment if nesting_max_depth == 1
+        nest_initial_segment if segments.length == 1
         nested_name = self.class.nested_transaction_name options[:transaction_name]
         segment = create_segment nested_name
         set_default_transaction_name(options[:transaction_name], category)
@@ -571,9 +571,6 @@ module NewRelic
                                AttributeFilter::DST_ERROR_COLLECTOR
 
         if http_response_code
-          add_agent_attribute(:httpResponseCode, http_response_code.to_s, default_destinations)
-          # Sending status code as an int with http.statusCode key is correct
-          # The above attribute is deprecated and should be removed in agent version 7.0.0
           add_agent_attribute(:'http.statusCode', http_response_code, default_destinations)
         end
 

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

@@ -82,15 +82,17 @@ module NewRelic
         end
 
         def install_browser_monitoring(config)
-          return if defined?(@browser_monitoring_installed) && @browser_monitoring_installed
-          @browser_monitoring_installed = true
-          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")
-          rescue => e
-            ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware", e)
+          @install_lock.synchronize do
+            return if defined?(@browser_monitoring_installed) && @browser_monitoring_installed
+            @browser_monitoring_installed = true
+            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")
+            rescue => e
+              ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware", e)
+            end
           end
         end
 

data/lib/new_relic/control/instance_methods.rb

@@ -165,6 +165,7 @@ module NewRelic
       protected
 
       def initialize(local_env, config_file_override=nil)
+        @install_lock = Mutex.new
         @local_env = local_env
         @started_in_env = nil
 

data/lib/new_relic/dependency_detection.rb

@@ -21,6 +21,7 @@ module DependencyDetection
     end
 
     @items << item
+    return item
   end
 
   def detect!
@@ -51,16 +52,25 @@ module DependencyDetection
   class Dependent
     attr_reader :executed
     attr_accessor :name
+    attr_writer :config_name
+    attr_reader :dependencies
+    attr_reader :prepend_conflicts
+
+
     def executed!
       @executed = true
     end
 
-    attr_reader :dependencies
+    def config_name
+      @config_name || @name
+    end
 
     def initialize
       @dependencies = []
       @executes = []
+      @prepend_conflicts = []
       @name = nil
+      @config_name = nil
     end
 
     def dependencies_satisfied?
@@ -70,13 +80,46 @@ module DependencyDetection
     def source_location_for klass, method_name
       Object.instance_method(:method).bind(klass.allocate).call(method_name).source_location.to_s
     end
-  
+
+    # Extracts the instrumented library name from the instrumenting module's name
+    # 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]
+    end
+
+    def log_and_instrument method, instrumenting_module, supportability_name
+      supportability_name ||= extract_supportability_name(instrumenting_module)
+      NewRelic::Agent.logger.info "Installing New Relic supported #{supportability_name} instrumentation using #{method}"
+      NewRelic::Agent.record_metric("Supportability/Instrumentation/#{supportability_name}/#{method}", 0.0)
+      yield
+    end
+
+    def prepend_instrument target_class, instrumenting_module, supportability_name=nil
+      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
+        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
+        instrumenting_module.instrument! target
+      end
+    end
+
     def execute
       @executes.each do |x|
         begin
           x.call
         rescue => err
-          NewRelic::Agent.logger.error( "Error while installing #{self.name} instrumentation:", err )
+          NewRelic::Agent.logger.error "Error while installing #{self.name} instrumentation:", err
           break
         end
       end
@@ -102,24 +145,87 @@ module DependencyDetection
     end
 
     def allowed_by_config?
-      # If we don't have a name, can't check config so allow it
-      return true if self.name.nil?
+      !(disabled_configured? || deprecated_disabled_configured?)
+    end
+
+    # TODO: Remove in 8.0
+    # will only return true if a disabled key is found and is truthy
+    def deprecated_disabled_configured?
+      return false if self.name.nil?
 
       key = "disable_#{self.name}".to_sym
-      if (::NewRelic::Agent.config[key] == true)
-        ::NewRelic::Agent.logger.debug("Not installing #{self.name} instrumentation because of configuration #{key}")
-        false
-      else
-        true
+      return false unless ::NewRelic::Agent.config[key] == true
+
+      ::NewRelic::Agent.logger.debug("Not installing #{self.name} instrumentation because of configuration #{key}")
+      ::NewRelic::Agent.logger.debug \
+        "[DEPRECATED] configuration #{key} for #{self.name} will be removed in the next major release." \
+        " Use `#{config_key}` with one of `#{VALID_CONFIG_VALUES.map(&:to_s).inspect}`"
+
+      return true
+    end
+
+    def config_key
+      return nil if self.config_name.nil?
+      @config_key ||= "instrumentation.#{self.config_name}".to_sym
+    end
+
+    VALID_CONFIG_VALUES = [:auto, :disabled, :prepend, :chain]
+    AUTO_CONFIG_VALUE = VALID_CONFIG_VALUES[0]
+
+    VALID_CONFIG_VALUES.each do |value|
+      define_method "#{value}_configured?" do
+        value == config_value
       end
     end
 
+    # returns only a valid value for instrumentation configuration
+    # If user uses "enabled" it's converted to "auto"
+    def valid_config_value retrieved_value
+      VALID_CONFIG_VALUES.include?(retrieved_value) ? retrieved_value : AUTO_CONFIG_VALUE
+    end
+
+    # fetches and transform potentially invalid value given to one of the valid config values
+    # logs the resolved value during debug mode.
+    def fetch_config_value(key)
+      valid_value = valid_config_value(::NewRelic::Agent.config[key].to_s.to_sym)
+      ::NewRelic::Agent.logger.debug("Using #{valid_value} configuration value for #{self.name} to configure instrumentation")
+      return valid_value
+    end
+
+    def config_value
+      return AUTO_CONFIG_VALUE unless config_key
+      fetch_config_value(config_key)
+    end
+
     def named(new_name)
       self.name = new_name
     end
 
+    def configure_with(new_config_name)
+      self.config_name = new_config_name
+    end
+
     def executes &block
       @executes << block if block_given?
     end
+
+    def conflicts_with_prepend &block
+      @prepend_conflicts << block if block_given?
+    end
+
+    def use_prepend?
+      prepend_configured? || (auto_configured? && !prepend_conflicts?)
+    end
+
+    def prepend_conflicts?
+      @prepend_conflicts.any? do |conflict|
+        begin
+          conflict.call
+        rescue => err
+          NewRelic::Agent.logger.error( "Error while checking prepend conflicts #{self.name}:", err )
+          false # assumes no conflicts exist since `prepend` is preferred method of instrumenting
+        end
+      end
+    end
   end
 end

data/lib/new_relic/noticed_error.rb

@@ -33,7 +33,7 @@ class NewRelic::NoticedError
   ERROR_CLASS_KEY    = "#{ERROR_PREFIX_KEY}.class"
   ERROR_EXPECTED_KEY = "#{ERROR_PREFIX_KEY}.expected"
 
-  def initialize(path, exception, timestamp = Time.now)
+  def initialize(path, exception, timestamp = Time.now, expected = false)
     @exception_id = exception.object_id
     @path = path
 
@@ -58,7 +58,7 @@ class NewRelic::NoticedError
     @attributes_from_notice_error = nil
     @attributes = nil
     @timestamp = timestamp
-    @expected = false
+    @expected = expected
   end
 
   def ==(other)
@@ -70,11 +70,7 @@ class NewRelic::NoticedError
   end
 
   def self.passes_message_allowlist(exception_class)
-    # For backwards compatibility until we remove :'strip_exception_messages.whitelist' config option
-
-    allowed = NewRelic::Agent.config[:'strip_exception_messages.allowed_classes'].concat(NewRelic::Agent.config[:'strip_exception_messages.whitelist'])
-
-    allowed.any? do |klass|
+    NewRelic::Agent.config[:'strip_exception_messages.allowed_classes'].any? do |klass|
       exception_class <= klass
     end
   end
@@ -108,7 +104,7 @@ class NewRelic::NoticedError
     params[:file_name]        = file_name   if file_name
     params[:line_number]      = line_number if line_number
     params[:stack_trace]      = stack_trace if stack_trace
-    params[:'error.expected'] = expected
+    params[ERROR_EXPECTED_KEY.to_sym] = expected
     params
   end
 

data/lib/new_relic/supportability_helper.rb

@@ -13,7 +13,6 @@ module NewRelic
     API_SUPPORTABILITY_METRICS = [
       :insert_distributed_trace_headers,
       :accept_distributed_trace_headers,
-      :create_distributed_trace_headers,
       :add_custom_attributes,
       :add_custom_span_attributes,
       :add_instrumentation,
@@ -75,7 +74,7 @@ module NewRelic
       caller_location = caller_locations.first.label
 
       message = "Bad argument passed to ##{caller_location}. " \
-        "Expected #{klass} for `#{name}` but got #{headers.class}"
+        "Expected #{klass} for `#{name}` but got #{arg.class}"
 
       NewRelic::Agent.logger.warn message
       nil

data/lib/new_relic/version.rb

@@ -10,8 +10,8 @@ module NewRelic
       parts.compact.join('.')
     end
 
-    MAJOR = 6
-    MINOR = 15
+    MAJOR = 7
+    MINOR = 2
     TINY  = 0
 
     begin