newrelic_rpm 6.8.0.360 → 8.13.1

data/lib/new_relic/agent/external.rb

@@ -1,10 +1,10 @@
-# 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/transaction/tracing'
-require 'new_relic/agent/cross_app_tracing'
-require 'new_relic/agent/cross_app_payload'
+require 'new_relic/agent/distributed_tracing/cross_app_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_payload'
 
 module NewRelic
   module Agent
@@ -18,44 +18,12 @@ module NewRelic
     module External
       extend self
 
-      # This method creates and starts an external request segment using the
-      # given library, URI, and procedure. This is used to time external calls
-      # made over HTTP.
-      #
-      # @param [String] library a string of the class name of the library used to
-      # make the external call, for example, 'Net::HTTP'.
-      #
-      # @param [String, URI] uri indicates the URI to which the
-      # external request is being made. The URI should begin with the protocol,
-      # for example, 'https://github.com'.
-      #
-      # @param [String] procedure the HTTP method being used for the external
-      # request as a string, for example, 'GET'.
-      #
-      # @api public
-      def start_segment(library: nil, uri: nil, procedure: nil)
-        Deprecator.deprecate 'External.start_segment',
-                             'Tracer#start_external_request_segment'
-
-        raise ArgumentError, 'Argument `library` is required' if library.nil?
-        raise ArgumentError, 'Argument `uri` is required' if uri.nil?
-        raise ArgumentError, 'Argument `procedure` is required' if procedure.nil?
-
-        ::NewRelic::Agent.record_api_supportability_metric(:start_segment)
-
-        ::NewRelic::Agent::Tracer.start_external_request_segment(
-          library: library,
-          uri: uri,
-          procedure: procedure
-        )
-      end
-
-      NON_HTTP_CAT_ID_HEADER  = 'NewRelicID'.freeze
+      NON_HTTP_CAT_ID_HEADER = 'NewRelicID'.freeze
       NON_HTTP_CAT_TXN_HEADER = 'NewRelicTransaction'.freeze
       NON_HTTP_CAT_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
       NON_HTTP_CAT_CONTENT_LENGTH = -1
 
-      # Process obfuscated +String+ indentifying a calling application and transaction that is also running a
+      # Process obfuscated +String+ identifying a calling application and transaction that is also running a
       # New Relic agent and save information in current transaction for inclusion in a trace. The +String+ is
       # generated by +get_request_metadata+ on the calling application.
       #
@@ -63,13 +31,13 @@ module NewRelic
       #
       # @api public
       #
-      def process_request_metadata request_metadata
+      def process_request_metadata(request_metadata)
         NewRelic::Agent.record_api_supportability_metric(:process_request_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
         state = NewRelic::Agent::Tracer.state
         if transaction = state.current_transaction
-          rmd = ::JSON.parse obfuscator.deobfuscate(request_metadata)
+          rmd = ::JSON.parse(obfuscator.deobfuscate(request_metadata))
 
           # handle/check ID
           #
@@ -78,26 +46,26 @@ module NewRelic
             #
             if txn_info = rmd[NON_HTTP_CAT_TXN_HEADER]
               payload = CrossAppPayload.new(id, transaction, txn_info)
-              transaction.cross_app_payload = payload
+              transaction.distributed_tracer.cross_app_payload = payload
 
-              CrossAppTracing.assign_intrinsic_transaction_attributes state
+              CrossAppTracing.assign_intrinsic_transaction_attributes(state)
             end
 
             # handle synthetics
             #
             if synth = rmd[NON_HTTP_CAT_SYNTHETICS_HEADER]
               transaction.synthetics_payload = synth
-              transaction.raw_synthetics_header = obfuscator.obfuscate ::JSON.dump(synth)
+              transaction.raw_synthetics_header = obfuscator.obfuscate(::JSON.dump(synth))
             end
 
           else
-            NewRelic::Agent.logger.error "error processing request metadata: invalid/non-trusted ID: '#{id}'"
+            NewRelic::Agent.logger.error("error processing request metadata: invalid/non-trusted ID: '#{id}'")
           end
 
           nil
         end
       rescue => e
-        NewRelic::Agent.logger.error 'error during process_request_metadata', e
+        NewRelic::Agent.logger.error('error during process_request_metadata', e)
       end
 
       # Obtain an obfuscated +String+ suitable for delivery across public networks that carries transaction
@@ -112,24 +80,24 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:get_response_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
-        return unless (transaction = Tracer.current_transaction)
-        return unless (cross_app_payload = transaction.cross_app_payload)
+        return unless (txn = Tracer.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
 
         # must freeze the name since we're responding with it
         #
-        transaction.freeze_name_and_execute_if_not_ignored do
+        txn.freeze_name_and_execute_if_not_ignored do
           # build response payload
           #
           rmd = {
-            NewRelicAppData: cross_app_payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
+            NewRelicAppData: payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
           }
 
           # obfuscate the generated response metadata JSON
           #
-          obfuscator.obfuscate ::JSON.dump(rmd)
+          obfuscator.obfuscate(::JSON.dump(rmd))
         end
       rescue => e
-        NewRelic::Agent.logger.error "error during get_response_metadata", e
+        NewRelic::Agent.logger.error("error during get_response_metadata", e)
       end
 
       private
@@ -137,7 +105,6 @@ module NewRelic
       def obfuscator
         CrossAppTracing.obfuscator
       end
-
     end
   end
 end

data/lib/new_relic/agent/guid_generator.rb

@@ -1,13 +1,10 @@
-# 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
 
 module NewRelic
   module Agent
     module GuidGenerator
-
-      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
-
       module_function
 
       # This method intentionally does not use SecureRandom, because it relies
@@ -15,14 +12,10 @@ module NewRelic
       # out of allocated file descriptors.
       # The guids generated by this method may not be _secure_, but they are
       # random enough for our purposes.
-      def generate_guid length = 16
-        guid = ''
-        length.times do |a|
-          guid << HEX_DIGITS[rand(16)]
-        end
-        guid
+      def generate_guid(length = 16)
+        guid = rand(16**length).to_s(16)
+        guid.length < length ? guid.rjust(length, "0") : guid
       end
-
     end
   end
 end

data/lib/new_relic/agent/harvester.rb

@@ -1,15 +1,14 @@
-# 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
 
 module NewRelic
   module Agent
     class Harvester
-
       attr_accessor :starting_pid
 
       # Inject target for after_fork call to avoid spawning thread in tests
-      def initialize(events, after_forker=NewRelic::Agent)
+      def initialize(events, after_forker = NewRelic::Agent)
         # We intentionally don't set our pid as started at this point.
         # Startup routines must call mark_started when they consider us set!
         @starting_pid = nil
@@ -22,8 +21,8 @@ module NewRelic
 
       def on_transaction(*_)
         return unless restart_in_children_enabled? &&
-                        needs_restart? &&
-                        harvest_thread_enabled?
+          needs_restart? &&
+          harvest_thread_enabled?
 
         restart_harvest_thread
       end

data/lib/new_relic/agent/heap.rb

@@ -1,12 +1,12 @@
-# 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
 
 module NewRelic
   module Agent
     # This class implements a min Heap. The first element is always the one with the
     # lowest priority. It is a tree structure that is represented as an array. The
-    # relationship between between nodes in the tree and indices in the array are as
+    # relationship between nodes in the tree and indices in the array are as
     # follows:
     #
     # parent_index      = (child_index -  1) / 2
@@ -18,8 +18,7 @@ module NewRelic
     #
 
     class Heap
-
-      # @param [Array] items an optional array of items to intialize the heap
+      # @param [Array] items an optional array of items to initialize the heap
       #
       # @param [Callable] priority_fn an optional priority function used to
       #   to compute the priority for an item. If it's not supplied priority
@@ -27,7 +26,7 @@ module NewRelic
       def initialize(items = nil, &priority_fn)
         @items = []
         @priority_fn = priority_fn || ->(x) { x }
-        items.each{ |item| push(item) } if items
+        items.each { |item| push(item) } if items
       end
 
       def [](index)
@@ -90,11 +89,11 @@ module NewRelic
         @priority_fn.call(@items[index])
       end
 
-      def parent_index_for child_index
+      def parent_index_for(child_index)
         (child_index - 1) / 2
       end
 
-      def left_child_index_for parent_index
+      def left_child_index_for(parent_index)
         2 * parent_index + 1
       end
 
@@ -135,6 +134,5 @@ module NewRelic
         @items[i], @items[j] = @items[j], @items[i]
       end
     end
-
   end
 end

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,11 +19,22 @@ 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)
@@ -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,81 @@
+# 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
+        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__]
+        end
+
+        def host
+          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
+        end
+
+        def method
+          raise NotImplementedError, MUST_IMPLEMENT_ERROR % [self.class, __method__]
+        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,46 @@ module NewRelic
           @curlobj._nr_http_verb
         end
 
-        def []( key )
-          @curlobj.headers[ key ]
+        def [](key)
+          @curlobj.headers[key]
         end
 
-        def []=( key, value )
-          @curlobj.headers[ key ] = value
+        def []=(key, value)
+          @curlobj.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
 
-
-      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 ||= String.new
+          @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
@@ -70,9 +85,8 @@ module NewRelic
         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
       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,19 @@ 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
       end
     end