newrelic_rpm 6.3.0.355 → 9.2.0

data/lib/new_relic/agent/hostname.rb

@@ -1,7 +1,9 @@
-# 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 'socket'
+require 'new_relic/helper'
 
 module NewRelic
   module Agent
@@ -17,16 +19,27 @@ module NewRelic
         end
       end
 
+      # Pass '-f' to the external executable 'hostname' to request the fully
+      # qualified domain name (fqdn). For implementations of 'hostname' that
+      # do not support '-f' (such as the one OpenBSD ships with), fall back
+      # to calling 'hostname' without the '-f'. If both ways of calling
+      # 'hostname' fail, or in a context where 'hostname' is not even
+      # available (within an AWS Lambda function, for example), call the
+      # 'get' method which uses Socket instead of an external executable.
       def self.get_fqdn
-        %x[hostname -f].chomp!
-      rescue => e
-        NewRelic::Agent.logger.debug "Unable to determine fqdn #{e}"
-        nil
+        begin
+          NewRelic::Helper.run_command('hostname -f')
+        rescue NewRelic::CommandRunFailedError
+          NewRelic::Helper.run_command('hostname')
+        end
+      rescue NewRelic::CommandExecutableNotFoundError, NewRelic::CommandRunFailedError => e
+        NewRelic::Agent.logger.debug("#{e.class} - #{e.message}")
+        get
       end
 
       def self.heroku_dyno_name_prefix(dyno_name)
         get_dyno_prefixes.find do |dyno_prefix|
-          dyno_name.start_with?(dyno_prefix + ".")
+          dyno_name.start_with?(dyno_prefix + '.')
         end
       end
 
@@ -44,11 +57,11 @@ module NewRelic
         ::
       ].freeze
 
-      def self.local? host_or_ip
+      def self.local?(host_or_ip)
         LOCALHOST.include?(host_or_ip)
       end
 
-      def self.get_external host_or_ip
+      def self.get_external(host_or_ip)
         local?(host_or_ip) ? get : host_or_ip
       end
     end

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

@@ -0,0 +1,69 @@
+# 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
+
+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.'
+
+      # This class provides a public interface for wrapping HTTP requests. This
+      # may be used to create wrappers that are compatible with New Relic's
+      # external request API.
+      #
+      # @api public
+      class AbstractRequest
+        %i[[] []= type host_from_header host method headers uri].each do |name|
+          define_method(name) do
+            not_implemented(name)
+          end
+        end
+
+        private
+
+        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
+      # 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?
+            raise ArgumentError, WHINY_NIL_ERROR % self.class
+          end
+
+          @wrapped_response = wrapped_response
+        end
+
+        def has_status_code?
+          !!status_code
+        end
+
+        # 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
+
+        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
+        # of HTTP status code from the response object
+        def get_status_code
+          get_status_code_using(:code)
+        end
+      end
+    end
+  end
+end

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

@@ -1,19 +1,18 @@
-# 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 'new_relic/agent/http_clients/abstract_request'
+require_relative 'abstract'
 
 module NewRelic
   module Agent
     module HTTPClients
-
       class CurbRequest
-        CURB = 'Curb'.freeze
-        LHOST = 'host'.freeze
-        UHOST = 'Host'.freeze
+        CURB = 'Curb'
+        LHOST = 'host'
+        UHOST = 'Host'
 
-        def initialize( curlobj )
+        def initialize(curlobj)
           @curlobj = curlobj
         end
 
@@ -33,45 +32,50 @@ module NewRelic
           @curlobj._nr_http_verb
         end
 
-        def []( key )
-          @curlobj.headers[ key ]
+        def [](key)
+          headers[key]
         end
 
-        def []=( key, value )
-          @curlobj.headers[ key ] = value
+        def []=(key, value)
+          headers[key] = value
         end
 
         def uri
-          @uri ||= NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(@curlobj.url)
+          @uri ||= URIUtil.parse_and_normalize_url(@curlobj.url)
         end
-      end
 
+        def headers
+          @curlobj.headers
+        end
+      end
 
-      class CurbResponse < AbstractRequest
-
-        def initialize(curlobj)
+      class CurbResponse < AbstractResponse
+        def initialize(wrapped_response)
+          super(wrapped_response)
           @headers = {}
-          @curlobj = curlobj
         end
 
         def [](key)
-          @headers[ key.downcase ]
+          @headers[key.downcase]
         end
 
         def to_hash
           @headers.dup
         end
 
-        def append_header_data( data )
-          key, value = data.split( /:\s*/, 2 )
-          @headers[ key.downcase ] = value
-          @curlobj._nr_header_str ||= ''
-          @curlobj._nr_header_str << data
+        def append_header_data(data)
+          key, value = data.split(/:\s*/, 2)
+          @headers[key.downcase] = value
+          @wrapped_response._nr_header_str ||= +''
+          @wrapped_response._nr_header_str << data
         end
 
-      end
+        private
 
+        def get_status_code
+          get_status_code_using(:response_code)
+        end
+      end
     end
-
   end
 end

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

@@ -1,20 +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 'new_relic/agent/http_clients/abstract_request'
+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
@@ -26,23 +26,38 @@ 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 < AbstractRequest
         attr_reader :method
 
-        EXCON = "Excon".freeze
-        LHOST = 'host'.freeze
-        UHOST = 'Host'.freeze
-        COLON = ':'.freeze
+        EXCON = 'Excon'
+        LHOST = 'host'
+        UHOST = 'Host'
+        COLON = ':'
 
         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
@@ -50,7 +65,6 @@ module NewRelic
         end
 
         def host_from_header
-          headers = @datum[:headers]
           if hostname = (headers[LHOST] || headers[UHOST])
             hostname.split(COLON).first
           end
@@ -61,18 +75,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
-          ::NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(
-            "#{@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

@@ -1,39 +1,34 @@
-# 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 'new_relic/agent/http_clients/abstract_request'
+require_relative 'abstract'
 
 module NewRelic
   module Agent
     module HTTPClients
-      class HTTPResponse
-        attr_reader :response
-
-        def initialize(response)
-          @response = response
-        end
-
+      class HTTPResponse < AbstractResponse
         def [](key)
-          _, value = response.headers.find { |k,_| key.downcase == k.downcase }
+          _, value = @wrapped_response.headers.find { |k, _| key.casecmp(k) == 0 }
           value unless value.nil?
         end
 
         def to_hash
-          response.headers
+          @wrapped_response.headers
         end
       end
 
       class HTTPRequest < AbstractRequest
-        HTTP_RB = 'http.rb'.freeze
-        HOST    = 'host'.freeze
-        COLON   = ':'.freeze
+        HTTP_RB = 'http.rb'
+        HOST = 'host'
+        COLON = ':'
 
-        attr_reader :request, :uri
+        def initialize(wrapped_request)
+          @wrapped_request = wrapped_request
+        end
 
-        def initialize(request)
-          @request = request
-          @uri = request.uri
+        def uri
+          @uri ||= URIUtil.parse_and_normalize_url(@wrapped_request.uri)
         end
 
         def type
@@ -47,19 +42,23 @@ module NewRelic
         end
 
         def host
-          host_from_header || request.host
+          host_from_header || @wrapped_request.host
         end
 
         def method
-          request.verb.upcase
+          @wrapped_request.verb.upcase
         end
 
         def [](key)
-          request.headers[key]
+          @wrapped_request.headers[key]
         end
 
         def []=(key, value)
-          request.headers[key] = value
+          @wrapped_request.headers[key] = value
+        end
+
+        def headers
+          @wrapped_request.headers.to_hash
         end
       end
     end

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

@@ -1,22 +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 'new_relic/agent/http_clients/abstract_request'
+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
@@ -24,21 +18,20 @@ module NewRelic
         end
 
         def to_hash
-          response.headers
+          @wrapped_response.headers
         end
       end
 
       class HTTPClientRequest < AbstractRequest
-        attr_reader :request, :uri
+        attr_reader :request
 
-        HTTP_CLIENT = "HTTPClient".freeze
+        HTTP_CLIENT = 'HTTPClient'.freeze
         LHOST = 'host'.freeze
         UHOST = 'Host'.freeze
         COLON = ':'.freeze
 
         def initialize(request)
           @request = request
-          @uri = request.header.request_uri
         end
 
         def type
@@ -59,13 +52,21 @@ module NewRelic
           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/net_http_wrappers.rb

@@ -1,26 +1,37 @@
-# 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 'new_relic/agent/http_clients/abstract_request'
+require_relative 'abstract'
+require 'resolv'
 
 module NewRelic
   module Agent
     module HTTPClients
+      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'.freeze
+        NET_HTTP = 'Net::HTTP'
 
         def type
           NET_HTTP
         end
 
-        HOST = 'host'.freeze
-        COLON = ':'.freeze
+        HOST = 'host'
+        COLON = ':'
 
         def host_from_header
           if hostname = self[HOST]
@@ -49,12 +60,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

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

@@ -1,30 +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 'new_relic/agent/http_clients/abstract_request'
+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
@@ -33,7 +29,7 @@ module NewRelic
         private
 
         def headers
-          @response.headers
+          @wrapped_response.headers
         end
       end
 
@@ -43,10 +39,10 @@ module NewRelic
           @uri = case request.url
             when ::URI then request.url
             else NewRelic::Agent::HTTPClients::URIUtil.parse_and_normalize_url(request.url)
-            end
+          end
         end
 
-        TYPHOEUS = "Typhoeus".freeze
+        TYPHOEUS = 'Typhoeus'.freeze
 
         def type
           TYPHOEUS
@@ -70,13 +66,17 @@ module NewRelic
         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