newrelic_rpm 6.15.0 → 9.7.1

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

@@ -1,4 +1,3 @@
-# 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
@@ -6,8 +5,8 @@
 module NewRelic
   module Agent
     module HTTPClients
-      MUST_IMPLEMENT_ERROR = "Subclasses of %s must implement a :%s method"
-      WHINY_NIL_ERROR = "%s cannot initialize with a nil wrapped_response object."
+      MUST_IMPLEMENT_ERROR = 'Subclasses of %s must implement a :%s method'
+      WHINY_NIL_ERROR = '%s cannot initialize with a nil wrapped_response object.'
 
       # This class provides a public interface for wrapping HTTP requests. This
       # may be used to create wrappers that are compatible with New Relic's
@@ -15,41 +14,32 @@ module NewRelic
       #
       # @api public
       class AbstractRequest
+        LHOST = 'host'
+        UHOST = 'Host'
+        COLON = ':'
 
-        def []
-          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
-        end
-
-        def []=
-          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
-        end
-
-        def type
-          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
-        end
-
-        def host_from_header
-          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
+        %i[[] []= type host_from_header host method headers uri].each do |name|
+          define_method(name) do
+            not_implemented(name)
+          end
         end
 
-        def host
-          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
-        end
+        private
 
-        def method
-          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
+        def not_implemented(method_name)
+          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, method_name]
         end
       end
 
-      # This class implements the adaptor pattern and is used internally provide 
+      # This class implements the adaptor pattern and is used internally provide
       # uniform access to the underlying HTTP Client's response object
       # NOTE: response_object should be non-nil!
       class AbstractResponse # :nodoc:
-
-        def initialize wrapped_response
-          if wrapped_response.nil? 
+        def initialize(wrapped_response)
+          if wrapped_response.nil?
             raise ArgumentError, WHINY_NIL_ERROR % self.class
           end
+
           @wrapped_response = wrapped_response
         end
 
@@ -57,24 +47,25 @@ module NewRelic
           !!status_code
         end
 
-        # most HTTP client libraries report the HTTP status code as an integer, so 
+        # most HTTP client libraries report the HTTP status code as an integer, so
         # we expect status_code to be set only if a non-zero value is present
         def status_code
           @status_code ||= get_status_code
         end
 
-        private 
+        private
 
-        def get_status_code_using method_name
+        def get_status_code_using(method_name)
           return unless @wrapped_response.respond_to?(method_name)
+
           code = @wrapped_response.send(method_name).to_i
           code == 0 ? nil : code
         end
 
-        # Override this method to memoize a non-zero Integer representation 
+        # Override this method to memoize a non-zero Integer representation
         # of HTTP status code from the response object
         def get_status_code
-          get_status_code_using :code
+          get_status_code_using(:code)
         end
       end
     end

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

@@ -0,0 +1,80 @@
+# 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'
+require 'resolv'
+
+module NewRelic
+  module Agent
+    module HTTPClients
+      class AsyncHTTPResponse < AbstractResponse
+        def get_status_code
+          get_status_code_using(:status)
+        end
+
+        def [](key)
+          to_hash[key.downcase]&.first
+        end
+
+        def to_hash
+          @wrapped_response.headers.to_h
+        end
+      end
+
+      class AsyncHTTPRequest < AbstractRequest
+        def initialize(connection, method, url, headers)
+          @connection = connection
+          @method = method
+          @url = ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(url)
+          @headers = headers
+        end
+
+        ASYNC_HTTP = 'Async::HTTP'
+
+        def type
+          ASYNC_HTTP
+        end
+
+        def host_from_header
+          if hostname = (self[LHOST] || self[UHOST])
+            hostname.split(COLON).first
+          end
+        end
+
+        def host
+          host_from_header || uri.host.to_s
+        end
+
+        def [](key)
+          return headers[key] unless headers.is_a?(Array)
+
+          headers.each do |header|
+            return header[1] if header[0].casecmp?(key)
+          end
+          nil
+        end
+
+        def []=(key, value)
+          if headers.is_a?(Array)
+            headers << [key, value]
+          else
+            headers[key] = value
+          end
+        end
+
+        def uri
+          @url
+        end
+
+        def headers
+          @headers
+        end
+
+        def method
+          @method
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# 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
@@ -8,13 +7,10 @@ require_relative 'abstract'
 module NewRelic
   module Agent
     module HTTPClients
-
-      class CurbRequest
+      class CurbRequest < AbstractRequest
         CURB = 'Curb'
-        LHOST = 'host'
-        UHOST = 'Host'
 
-        def initialize curlobj
+        def initialize(curlobj)
           @curlobj = curlobj
         end
 
@@ -34,23 +30,26 @@ module NewRelic
           @curlobj._nr_http_verb
         end
 
-        def []( key )
-          @curlobj.headers[key]
+        def [](key)
+          headers[key]
         end
 
         def []=(key, value)
-          @curlobj.headers[key] = value
+          headers[key] = value
         end
 
         def uri
           @uri ||= URIUtil.parse_and_normalize_url(@curlobj.url)
         end
+
+        def headers
+          @curlobj.headers
+        end
       end
 
       class CurbResponse < AbstractResponse
-
-        def initialize wrapped_response
-          super wrapped_response
+        def initialize(wrapped_response)
+          super(wrapped_response)
           @headers = {}
         end
 
@@ -62,21 +61,19 @@ module NewRelic
           @headers.dup
         end
 
-        def append_header_data data
+        def append_header_data(data)
           key, value = data.split(/:\s*/, 2)
           @headers[key.downcase] = value
-          @wrapped_response._nr_header_str ||= String.new
+          @wrapped_response._nr_header_str ||= +''
           @wrapped_response._nr_header_str << data
         end
 
         private
 
         def get_status_code
-          get_status_code_using :response_code
+          get_status_code_using(:response_code)
         end
       end
-
     end
-
   end
 end

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

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

@@ -1,4 +1,3 @@
-# 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
@@ -9,8 +8,8 @@ module NewRelic
   module Agent
     module HTTPClients
       class ExconHTTPResponse < AbstractResponse
-        def initialize wrapped_response
-          super wrapped_response
+        def initialize(wrapped_response)
+          super(wrapped_response)
 
           # Since HTTP headers are case-insensitive, we normalize all of them to
           # upper case here, and then also in our [](key) implementation.
@@ -30,9 +29,9 @@ module NewRelic
 
         private
 
-        def get_attribute name
-          if @wrapped_response.respond_to?(name) 
-            @wrapped_response.send(name) 
+        def get_attribute(name)
+          if @wrapped_response.respond_to?(name)
+            @wrapped_response.send(name)
           else
             @wrapped_response[name]
           end
@@ -47,18 +46,15 @@ module NewRelic
       class ExconHTTPRequest < AbstractRequest
         attr_reader :method
 
-        EXCON = "Excon"
-        LHOST = 'host'
-        UHOST = 'Host'
-        COLON = ':'
+        EXCON = 'Excon'
 
         def initialize(datum)
           @datum = datum
 
           @method = @datum[:method].to_s.upcase
           @scheme = @datum[:scheme]
-          @port   = @datum[:port]
-          @path   = @datum[:path]
+          @port = @datum[:port]
+          @path = @datum[:path]
         end
 
         def type
@@ -66,7 +62,6 @@ module NewRelic
         end
 
         def host_from_header
-          headers = @datum[:headers]
           if hostname = (headers[LHOST] || headers[UHOST])
             hostname.split(COLON).first
           end
@@ -77,17 +72,20 @@ 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
+          URIUtil.parse_and_normalize_url(url)
+        end
+
+        def headers
+          @datum[:headers]
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# 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
@@ -10,7 +9,7 @@ module NewRelic
     module HTTPClients
       class HTTPResponse < AbstractResponse
         def [](key)
-          _, value = @wrapped_response.headers.find{ |k, _| key.downcase == k.downcase }
+          _, value = @wrapped_response.headers.find { |k, _| key.casecmp(k) == 0 }
           value unless value.nil?
         end
 
@@ -21,10 +20,8 @@ module NewRelic
 
       class HTTPRequest < AbstractRequest
         HTTP_RB = 'http.rb'
-        HOST    = 'host'
-        COLON   = ':'
 
-        def initialize wrapped_request
+        def initialize(wrapped_request)
           @wrapped_request = wrapped_request
         end
 
@@ -37,7 +34,7 @@ module NewRelic
         end
 
         def host_from_header
-          if hostname = self[HOST]
+          if hostname = self[LHOST]
             hostname.split(COLON).first
           end
         end
@@ -57,6 +54,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

@@ -1,4 +1,3 @@
-# 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
@@ -9,10 +8,9 @@ module NewRelic
   module Agent
     module HTTPClients
       class HTTPClientResponse < AbstractResponse
-
         def [](key)
-          @wrapped_response.headers.each do |k,v|
-            if key.downcase == k.downcase
+          @wrapped_response.headers.each do |k, v|
+            if key.casecmp(k) == 0
               return v
             end
           end
@@ -27,10 +25,7 @@ module NewRelic
       class HTTPClientRequest < AbstractRequest
         attr_reader :request
 
-        HTTP_CLIENT = "HTTPClient".freeze
-        LHOST = 'host'.freeze
-        UHOST = 'Host'.freeze
-        COLON = ':'.freeze
+        HTTP_CLIENT = 'HTTPClient'.freeze
 
         def initialize(request)
           @request = request
@@ -59,12 +54,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,91 @@
+# 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'
+
+        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

@@ -1,15 +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.
 # frozen_string_literal: true
 
 require_relative 'abstract'
+require 'resolv'
 
 module NewRelic
   module Agent
     module HTTPClients
       class NetHTTPResponse < AbstractResponse
-
         def [](key)
           @wrapped_response[key]
         end
@@ -31,11 +30,8 @@ module NewRelic
           NET_HTTP
         end
 
-        HOST = 'host'
-        COLON = ':'
-
         def host_from_header
-          if hostname = self[HOST]
+          if hostname = self[LHOST]
             hostname.split(COLON).first
           end
         end
@@ -61,12 +57,21 @@ module NewRelic
           when /^https?:\/\//
             ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(@request.path)
           else
+            connection_address = @connection.address
+            if Resolv::IPv6::Regex.match?(connection_address)
+              connection_address = "[#{connection_address}]"
+            end
+
             scheme = @connection.use_ssl? ? 'https' : 'http'
             ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(
-              "#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}"
-              )
+              "#{scheme}://#{connection_address}:#{@connection.port}#{@request.path}"
+            )
           end
         end
+
+        def headers
+          @request.instance_variable_get(:@header)
+        end
       end
     end
   end