newrelic_rpm 3.12.0.288 → 9.10.2

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,18 +1,20 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# 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
-      class ExconHTTPResponse
-        def initialize(response)
-          @response = response
+      class ExconHTTPResponse < AbstractResponse
+        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.
           @normalized_headers = {}
-          headers = response.respond_to?(:headers) ? response.headers : response[:headers]
-          (headers || {}).each do |key, val|
+          (get_attribute(:headers) || {}).each do |key, val|
             @normalized_headers[key.upcase] = val
           end
         end
@@ -24,42 +26,66 @@ module NewRelic
         def to_hash
           @normalized_headers.dup
         end
+
+        private
+
+        def get_attribute(name)
+          if @wrapped_response.respond_to?(name)
+            @wrapped_response.send(name)
+          else
+            @wrapped_response[name]
+          end
+        end
+
+        def get_status_code
+          code = get_attribute(:status).to_i
+          code == 0 ? nil : code
+        end
       end
 
-      class ExconHTTPRequest
+      class ExconHTTPRequest < AbstractRequest
+        attr_reader :method
+
+        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
 
-          headers = @datum[:headers]
-          if hostname = (headers['host'] || headers['Host'])
-            @host = hostname.split(':').first
-          else
-            @host = @datum[:host]
-          end
+        def type
+          EXCON
         end
 
-        attr_reader :host, :method
+        def host_from_header
+          if hostname = (headers[LHOST] || headers[UHOST])
+            hostname.split(COLON).first
+          end
+        end
 
-        def type
-          "Excon"
+        def host
+          host_from_header || @datum[:host]
         end
 
         def [](key)
-          @datum[:headers][key]
+          headers[key]
         end
 
         def []=(key, value)
-          @datum[:headers] ||= {}
-          @datum[:headers][key] = value
+          headers[key] = value
         end
 
         def uri
-          URI.parse("#{@scheme}://#{@host}:#{@port}#{@path}")
+          url = "#{@scheme}://#{host}:#{@port}#{@path}"
+          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

@@ -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_relative 'abstract'
+
+module NewRelic
+  module Agent
+    module HTTPClients
+      class HTTPResponse < AbstractResponse
+        def [](key)
+          _, value = @wrapped_response.headers.find { |k, _| key.casecmp(k) == 0 }
+          value unless value.nil?
+        end
+
+        def to_hash
+          @wrapped_response.headers
+        end
+      end
+
+      class HTTPRequest < AbstractRequest
+        HTTP_RB = 'http.rb'
+
+        def initialize(wrapped_request)
+          @wrapped_request = wrapped_request
+        end
+
+        def uri
+          @uri ||= URIUtil.parse_and_normalize_url(@wrapped_request.uri)
+        end
+
+        def type
+          HTTP_RB
+        end
+
+        def host_from_header
+          if hostname = self[LHOST]
+            hostname.split(COLON).first
+          end
+        end
+
+        def host
+          host_from_header || @wrapped_request.host
+        end
+
+        def method
+          @wrapped_request.verb.upcase
+        end
+
+        def [](key)
+          @wrapped_request.headers[key]
+        end
+
+        def []=(key, value)
+          @wrapped_request.headers[key] = value
+        end
+
+        def headers
+          @wrapped_request.headers.to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -1,20 +1,16 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# 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
-      class HTTPClientResponse
-        attr_reader :response
-
-        def initialize(response)
-          @response = response
-        end
-
+      class HTTPClientResponse < AbstractResponse
         def [](key)
-          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
@@ -22,41 +18,52 @@ module NewRelic
         end
 
         def to_hash
-          response.headers
+          @wrapped_response.headers
         end
       end
 
-      class HTTPClientRequest
-        attr_reader :request, :uri
+      class HTTPClientRequest < AbstractRequest
+        attr_reader :request
+
+        HTTP_CLIENT = 'HTTPClient'.freeze
 
         def initialize(request)
           @request = request
-          @uri = request.header.request_uri
         end
 
         def type
-          "HTTPClient"
+          HTTP_CLIENT
         end
 
         def method
           request.header.request_method
         end
 
-        def host
-          if hostname = (self['host'] || self['Host'])
-            hostname.split(':').first
-          else
-            uri.host.to_s
+        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 uri
+          @uri ||= URIUtil.parse_and_normalize_url(request.header.request_uri)
+        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,28 +1,45 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# 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 NetHTTPRequest
+      class NetHTTPResponse < AbstractResponse
+        def [](key)
+          @wrapped_response[key]
+        end
+
+        def to_hash
+          @wrapped_response.to_hash
+        end
+      end
+
+      class NetHTTPRequest < AbstractRequest
         def initialize(connection, request)
           @connection = connection
           @request = request
         end
 
+        NET_HTTP = 'Net::HTTP'
+
         def type
-          'Net::HTTP'
+          NET_HTTP
         end
 
-        def host
-          if hostname = self['host']
-            hostname.split(':').first
-          else
-            @connection.address
+        def host_from_header
+          if hostname = self[LHOST]
+            hostname.split(COLON).first
           end
         end
 
+        def host
+          host_from_header || @connection.address
+        end
+
         def method
           @request.method
         end
@@ -38,12 +55,23 @@ module NewRelic
         def uri
           case @request.path
           when /^https?:\/\//
-            URI(@request.path)
+            ::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'
-            URI("#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}")
+            ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(
+              "#{scheme}://#{connection_address}:#{@connection.port}#{@request.path}"
+            )
           end
         end
+
+        def headers
+          @request.instance_variable_get(:@header)
+        end
       end
     end
   end

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

@@ -1,28 +1,26 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# 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
-      class TyphoeusHTTPResponse
-        def initialize(response)
-          @response = response
-        end
-
+      class TyphoeusHTTPResponse < AbstractResponse
         def [](key)
           unless headers.nil?
             result = headers[key]
 
             # Typhoeus 0.5.3 has a bug where asking the headers hash for a
-            # non-existent header will return the hash itself, not what we want.
+            # nonexistent header will return the hash itself, not what we want.
             result == headers ? nil : result
           end
         end
 
         def to_hash
           hash = {}
-          headers.each do |(k,v)|
+          headers.each do |(k, v)|
             hash[k] = v
           end
           hash
@@ -31,39 +29,51 @@ module NewRelic
         private
 
         def headers
-          @response.headers
+          @wrapped_response.headers
         end
       end
 
-      class TyphoeusHTTPRequest
+      class TyphoeusHTTPRequest < AbstractRequest
         def initialize(request)
           @request = request
           @uri = case request.url
             when ::URI then request.url
-            else NewRelic::Agent::HTTPClients::URIUtil.parse_url(request.url)
-            end
+            else NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(request.url)
+          end
         end
 
+        TYPHOEUS = 'Typhoeus'.freeze
+
         def type
-          "Typhoeus"
+          TYPHOEUS
+        end
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
         end
 
         def host
-          self['host'] || self['Host'] || @uri.host
+          host_from_header || @uri.host
         end
 
+        GET = 'GET'.freeze
+
         def method
-          (@request.options[:method] || 'GET').to_s.upcase
+          (@request.options[:method] || GET).to_s.upcase
         end
 
         def [](key)
-          return nil unless @request.options && @request.options[:headers]
-          @request.options[:headers][key]
+          return nil unless @request.options && headers
+
+          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