newrelic_rpm 8.15.0 → 9.6.0

data/lib/new_relic/agent/http_clients/ethon_wrappers.rb

@@ -0,0 +1,111 @@
+# 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 'uri'
+require_relative 'abstract'
+
+module NewRelic
+  module Agent
+    module HTTPClients
+      class EthonHTTPResponse < AbstractResponse
+        def initialize(easy)
+          @easy = easy
+        end
+
+        def status_code
+          @easy.response_code
+        end
+
+        def [](key)
+          headers[format_key(key)]
+        end
+
+        def headers
+          # Ethon::Easy#response_headers will return '' if headers are unset
+          @easy.response_headers.scan(/\n([^:]+?): ([^:\n]+?)\r/).each_with_object({}) do |pair, hash|
+            hash[format_key(pair[0])] = pair[1]
+          end
+        end
+        alias to_hash headers
+
+        private
+
+        def format_key(key)
+          key.tr('-', '_').downcase
+        end
+      end
+
+      class EthonHTTPRequest < AbstractRequest
+        attr_reader :uri
+
+        DEFAULT_ACTION = 'GET'
+        DEFAULT_HOST = 'UNKNOWN_HOST'
+        ETHON = 'Ethon'
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+
+        def initialize(easy)
+          @easy = easy
+          @uri = uri_from_easy
+        end
+
+        def type
+          ETHON
+        end
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
+        end
+
+        def uri_from_easy
+          # anticipate `Ethon::Easy#url` being `example.com` without a protocol
+          # defined and use an 'http' protocol prefix for `URI.parse` to work
+          # with the URL as desired
+          url_str = @easy.url.match?(':') ? @easy.url : "http://#{@easy.url}"
+          begin
+            URI.parse(url_str)
+          rescue URI::InvalidURIError => e
+            NewRelic::Agent.logger.debug("Failed to parse URI '#{url_str}': #{e.class} - #{e.message}")
+            URI.parse(NewRelic::EMPTY_STR)
+          end
+        end
+
+        def host
+          host_from_header || uri.host&.downcase || DEFAULT_HOST
+        end
+
+        def method
+          return DEFAULT_ACTION unless @easy.instance_variable_defined?(action_instance_var)
+
+          @easy.instance_variable_get(action_instance_var)
+        end
+
+        def action_instance_var
+          NewRelic::Agent::Instrumentation::Ethon::Easy::ACTION_INSTANCE_VAR
+        end
+
+        def []=(key, value)
+          headers[key] = value
+          @easy.headers = headers
+        end
+
+        def headers
+          @headers ||= if @easy.instance_variable_defined?(headers_instance_var)
+            @easy.instance_variable_get(headers_instance_var)
+          else
+            {}
+          end
+        end
+
+        def headers_instance_var
+          NewRelic::Agent::Instrumentation::Ethon::Easy::HEADERS_INSTANCE_VAR
+        end
+
+        def [](key)
+          headers[key]
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/http_clients/excon_wrappers.rb

@@ -46,7 +46,7 @@ module NewRelic
       class ExconHTTPRequest < AbstractRequest
         attr_reader :method
 
-        EXCON = "Excon"
+        EXCON = 'Excon'
         LHOST = 'host'
         UHOST = 'Host'
         COLON = ':'
@@ -65,7 +65,6 @@ module NewRelic
         end
 
         def host_from_header
-          headers = @datum[:headers]
           if hostname = (headers[LHOST] || headers[UHOST])
             hostname.split(COLON).first
           end
@@ -76,18 +75,21 @@ module NewRelic
         end
 
         def [](key)
-          @datum[:headers][key]
+          headers[key]
         end
 
         def []=(key, value)
-          @datum[:headers] ||= {}
-          @datum[:headers][key] = value
+          headers[key] = value
         end
 
         def uri
           url = "#{@scheme}://#{host}:#{@port}#{@path}"
           URIUtil.parse_and_normalize_url(url)
         end
+
+        def headers
+          @datum[:headers]
+        end
       end
     end
   end

data/lib/new_relic/agent/http_clients/http_rb_wrappers.rb

@@ -56,6 +56,10 @@ module NewRelic
         def []=(key, value)
           @wrapped_request.headers[key] = value
         end
+
+        def headers
+          @wrapped_request.headers.to_hash
+        end
       end
     end
   end

data/lib/new_relic/agent/http_clients/httpclient_wrappers.rb

@@ -25,7 +25,7 @@ module NewRelic
       class HTTPClientRequest < AbstractRequest
         attr_reader :request
 
-        HTTP_CLIENT = "HTTPClient".freeze
+        HTTP_CLIENT = 'HTTPClient'.freeze
         LHOST = 'host'.freeze
         UHOST = 'Host'.freeze
         COLON = ':'.freeze
@@ -57,12 +57,16 @@ module NewRelic
         end
 
         def [](key)
-          request.headers[key]
+          headers[key]
         end
 
         def []=(key, value)
           request.http_header[key] = value
         end
+
+        def headers
+          request.headers
+        end
       end
     end
   end

data/lib/new_relic/agent/http_clients/httpx_wrappers.rb

@@ -0,0 +1,93 @@
+# 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_relative 'abstract'
+
+module NewRelic
+  module Agent
+    module HTTPClients
+      # HTTPX returns an instance of HTTPX::ErrorResponse on error,
+      # and that instance itself yields the underlying HTTP response
+      # object via #response, but depending on the error that HTTP
+      # response object could be unset.
+      class HTTPXErrorResponse
+        def status; end
+        def headers; {}; end
+      end
+
+      class HTTPXHTTPResponse < AbstractResponse
+        def initialize(response)
+          if response.is_a?(::HTTPX::ErrorResponse)
+            @response = response.response || HTTPXErrorResponse.new
+          else
+            @response = response
+          end
+        end
+
+        def status_code
+          @response.status
+        end
+
+        def [](key)
+          headers[format_key(key)]
+        end
+
+        def headers
+          headers ||= @response.headers.to_hash.each_with_object({}) do |(k, v), h|
+            h[format_key(k)] = v
+          end
+        end
+        alias to_hash headers
+
+        private
+
+        def format_key(key)
+          key.tr('-', '_').downcase
+        end
+      end
+
+      class HTTPXHTTPRequest < AbstractRequest
+        attr_reader :uri
+
+        DEFAULT_HOST = 'UNKNOWN_HOST'
+        TYPE = 'HTTPX'
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+
+        def initialize(request)
+          @request = request
+          @uri = request.uri
+        end
+
+        def type
+          TYPE
+        end
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
+        end
+
+        def host
+          host_from_header || uri.host&.downcase || DEFAULT_HOST
+        end
+
+        def method
+          @request.verb
+        end
+
+        def []=(key, value)
+          @request.headers[key] = value
+        end
+
+        def headers
+          @request.headers
+        end
+
+        def [](key)
+          @request.headers[key]
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/http_clients/net_http_wrappers.rb

@@ -61,7 +61,7 @@ module NewRelic
             ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(@request.path)
           else
             connection_address = @connection.address
-            if connection_address =~ Resolv::IPv6::Regex
+            if Resolv::IPv6::Regex.match?(connection_address)
               connection_address = "[#{connection_address}]"
             end
 
@@ -71,6 +71,10 @@ module NewRelic
             )
           end
         end
+
+        def headers
+          @request.instance_variable_get(:@header)
+        end
       end
     end
   end

data/lib/new_relic/agent/http_clients/typhoeus_wrappers.rb

@@ -42,7 +42,7 @@ module NewRelic
           end
         end
 
-        TYPHOEUS = "Typhoeus".freeze
+        TYPHOEUS = 'Typhoeus'.freeze
 
         def type
           TYPHOEUS
@@ -66,14 +66,17 @@ module NewRelic
         end
 
         def [](key)
-          return nil unless @request.options && @request.options[:headers]
+          return nil unless @request.options && headers
 
-          @request.options[:headers][key]
+          headers[key]
         end
 
         def []=(key, value)
-          @request.options[:headers] ||= {}
-          @request.options[:headers][key] = value
+          headers[key] = value
+        end
+
+        def headers
+          @request.options[:headers] || {}
         end
 
         def uri

data/lib/new_relic/agent/http_clients/uri_util.rb

@@ -36,11 +36,11 @@ module NewRelic
               uri = ::URI.parse(url)
             end
           end
-          uri.host.downcase! unless uri.host.nil?
+          uri.host&.downcase!
           uri
         end
 
-        QUESTION_MARK = "?"
+        QUESTION_MARK = '?'
 
         def self.strip_query_string(fragment)
           if fragment.include?(QUESTION_MARK)

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

@@ -10,9 +10,7 @@ module NewRelic
       class ActionCableSubscriber < NotificationsSubscriber
         PERFORM_ACTION = 'perform_action.action_cable'.freeze
 
-        def start(name, id, payload) # THREAD_LOCAL_ACCESS
-          return unless state.is_execution_traced?
-
+        def start_segment(name, id, payload) # THREAD_LOCAL_ACCESS
           finishable = if name == PERFORM_ACTION
             Tracer.start_transaction_or_segment(
               name: transaction_name_from_payload(payload),
@@ -22,21 +20,6 @@ module NewRelic
             Tracer.start_segment(name: metric_name_from_payload(name, payload))
           end
           push_segment(id, finishable)
-        rescue => e
-          log_notification_error(e, name, 'start')
-        end
-
-        def finish(name, id, payload) # THREAD_LOCAL_ACCESS
-          return unless state.is_execution_traced?
-
-          if exception = exception_object(payload)
-            NewRelic::Agent.notice_error(exception)
-          end
-
-          finishable = pop_segment(id)
-          finishable.finish if finishable
-        rescue => e
-          log_notification_error(e, name, 'finish')
         end
 
         private
@@ -46,7 +29,11 @@ module NewRelic
         end
 
         def metric_name_from_payload(name, payload)
-          "Ruby/ActionCable/#{payload[:channel_class]}/#{action_name(name)}"
+          "Ruby/ActionCable/#{metric_name(payload)}/#{action_name(name)}"
+        end
+
+        def metric_name(payload)
+          payload[:broadcasting] || payload[:channel_class]
         end
 
         DOT_ACTION_CABLE = '.action_cable'.freeze

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

@@ -0,0 +1,42 @@
+# 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/notifications_subscriber'
+require 'new_relic/agent/instrumentation/ignore_actions'
+require 'new_relic/agent/parameter_filtering'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionControllerOtherSubscriber < NotificationsSubscriber
+        def add_segment_params(segment, payload)
+          segment.params[:filter] = payload[:filter] if payload[:filter]
+          segment.params[:keys] = payload[:keys] if payload[:keys]
+          segment.params[:original_path] = payload[:request].original_fullpath if payload[:request]
+
+          if payload[:context]
+            segment.params[:action] = payload[:context][:action]
+            segment.params[:controller] = payload[:context][:controller]
+          end
+        end
+
+        def metric_name(name, payload)
+          controller_name = controller_name_for_metric(payload)
+          "Ruby/ActionController#{"/#{controller_name}" if controller_name}/#{name.gsub('.action_controller', '')}"
+        end
+
+        def controller_name_for_metric(payload)
+          return unless payload
+          # redirect_to
+          return payload[:request].controller_class.controller_path if payload[:request].respond_to?(:controller_class) && payload[:request].controller_class&.respond_to?(:controller_path)
+
+          # unpermitted_parameters
+          if payload[:context]&.[](:controller) && constantized_class = ::NewRelic::LanguageSupport.constantize(payload[:context][:controller])
+            constantized_class.respond_to?(:controller_path) ? constantized_class.controller_path : nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module NewRelic
           else
             # if this transaction is ignored, make sure child
             # transaction are also ignored
-            state.current_transaction.ignore! if state.current_transaction
+            state.current_transaction&.ignore!
             NewRelic::Agent.instance.push_trace_execution_flag(false)
           end
         rescue => e
@@ -90,7 +90,8 @@ module NewRelic
         end
 
         def queue_start(request)
-          if request && request.respond_to?(:env)
+          # the following line needs else branch coverage
+          if request && request.respond_to?(:env) # rubocop:disable Style/SafeNavigation
             QueueTime.parse_frontend_timestamp(request.env, Process.clock_gettime(Process::CLOCK_REALTIME))
           end
         end

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

@@ -0,0 +1,31 @@
+# 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_dispatch_subscriber'
+
+DependencyDetection.defer do
+  named :action_dispatch
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_dispatch]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionDispatch) &&
+      defined?(ActionPack) &&
+      ActionPack.respond_to?(:gem_version) &&
+      ActionPack.gem_version >= Gem::Version.new('6.0.0') && # notifications for dispatch added in Rails 6
+      !NewRelic::Agent::Instrumentation::ActionDispatchSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionDispatch instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A[^\.]+\.action_dispatch\z/,
+      NewRelic::Agent::Instrumentation::ActionDispatchSubscriber.new)
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionDispatchSubscriber < NotificationsSubscriber
+        def start(name, id, payload)
+          return unless state.is_execution_traced?
+
+          start_segment(name, id, payload)
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload)
+          return unless state.is_execution_traced?
+
+          finish_segment(id, payload)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def start_segment(name, id, payload)
+          segment = Tracer.start_segment(name: metric_name(name, payload))
+          push_segment(id, segment)
+        end
+
+        def finish_segment(id, payload)
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
+        end
+
+        def metric_name(name, payload)
+          middleware = payload[:middleware]
+          method = method_from_name(name)
+          "Ruby/ActionDispatch/#{middleware}/#{method}"
+        end
+
+        PATTERN = /\A([^\.]+)\.action_dispatch\z/
+        UNKNOWN = 'unknown'.freeze
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = UNKNOWN
+          end
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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_mailbox_subscriber'
+
+DependencyDetection.defer do
+  named :action_mailbox
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_mailbox]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionMailbox) &&
+      ActionMailbox.respond_to?(:gem_version) && # 'require "action_mailbox"' doesn't require version...
+      ActionMailbox.gem_version >= Gem::Version.new('7.1.0.alpha') && # notifications added in Rails 7.1
+      !NewRelic::Agent::Instrumentation::ActionMailboxSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionMailbox instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A[^\.]+\.action_mailbox\z/,
+      NewRelic::Agent::Instrumentation::ActionMailboxSubscriber.new)
+  end
+end

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

@@ -0,0 +1,33 @@
+# 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/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionMailboxSubscriber < NotificationsSubscriber
+        def metric_name(name, payload)
+          mailbox = payload[:mailbox].class.name
+          method = method_from_name(name)
+          "Ruby/ActionMailbox/#{mailbox}/#{method}"
+        end
+
+        PATTERN = /\A([^\.]*)\.action_mailbox\z/
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = NewRelic::UNKNOWN
+          end
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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_mailer_subscriber'
+
+DependencyDetection.defer do
+  named :action_mailer
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_mailer]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionMailer) &&
+      ActionMailer.respond_to?(:gem_version) &&
+      ActionMailer.gem_version >= Gem::Version.new('5.0') &&
+      !NewRelic::Agent::Instrumentation::ActionMailerSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionMailer instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A(?:[^\.]+)\.action_mailer\z/,
+      NewRelic::Agent::Instrumentation::ActionMailerSubscriber.new)
+  end
+end