newrelic_rpm 8.15.0 → 9.6.0

data/lib/new_relic/agent/new_relic_service.rb

@@ -3,7 +3,6 @@
 # frozen_string_literal: true
 
 require 'zlib'
-require 'timeout'
 require 'new_relic/agent/audit_logger'
 require 'new_relic/agent/new_relic_service/encoders'
 require 'new_relic/agent/new_relic_service/marshaller'
@@ -19,7 +18,13 @@ module NewRelic
 
       # These include Errno connection errors, and all indicate that the
       # underlying TCP connection may be in a bad state.
-      CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
+      CONNECTION_ERRORS = [Net::OpenTimeout, Net::ReadTimeout, EOFError, SystemCallError, SocketError]
+      # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until Ruby 2.6.
+      #       Once support for Ruby 2.5 is dropped, we should simply include
+      #       Net::WriteTimeout in the connection errors array directly instead
+      #       of with a conditional
+      CONNECTION_ERRORS << Net::WriteTimeout if defined?(Net::WriteTimeout)
+      CONNECTION_ERRORS.freeze
 
       # The maximum number of times to attempt an HTTP request
       MAX_ATTEMPTS = 2
@@ -65,7 +70,7 @@ module NewRelic
         Agent.config.register_callback(:marshaller) do |marshaller|
           if marshaller != 'json'
             ::NewRelic::Agent.logger.warn("Non-JSON marshaller '#{marshaller}' requested but not supported, using " \
-              "JSON marshaller instead. pruby marshalling has been removed as of version 3.14.0.")
+              'JSON marshaller instead. pruby marshalling has been removed as of version 3.14.0.')
           end
 
           @marshaller = JsonMarshaller.new
@@ -195,16 +200,16 @@ module NewRelic
       def error_event_data(data)
         metadata, items = data
         response = invoke_remote(:error_event_data, [@agent_id, *data], :item_count => items.size)
-        NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Sent", :count => items.size)
-        NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Seen", :count => metadata[:events_seen])
+        NewRelic::Agent.record_metric('Supportability/Events/TransactionError/Sent', :count => items.size)
+        NewRelic::Agent.record_metric('Supportability/Events/TransactionError/Seen', :count => metadata[:events_seen])
         response
       end
 
       def span_event_data(data)
         metadata, items = data
         response = invoke_remote(:span_event_data, [@agent_id, *data], :item_count => items.size)
-        NewRelic::Agent.record_metric("Supportability/Events/SpanEvents/Sent", :count => items.size)
-        NewRelic::Agent.record_metric("Supportability/Events/SpanEvents/Seen", :count => metadata[:events_seen])
+        NewRelic::Agent.record_metric('Supportability/Events/SpanEvents/Sent', :count => items.size)
+        NewRelic::Agent.record_metric('Supportability/Events/SpanEvents/Seen', :count => metadata[:events_seen])
         response
       end
 
@@ -305,7 +310,7 @@ module NewRelic
         conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
         set_cert_store(conn)
       rescue StandardError, LoadError
-        msg = "SSL is not available in the environment; please install SSL support."
+        msg = 'SSL is not available in the environment; please install SSL support.'
         raise UnrecoverableAgentException.new(msg)
       end
 
@@ -313,19 +318,21 @@ module NewRelic
         if NewRelic::Agent.config[:ca_bundle_path]
           conn.cert_store = ssl_cert_store
         else
-          ::NewRelic::Agent.logger.debug("Using default security certificates")
+          ::NewRelic::Agent.logger.debug('Using default security certificates')
         end
       end
 
       def start_connection(conn)
         NewRelic::Agent.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
-        Timeout.timeout(@request_timeout) { conn.start }
-        conn
+        conn.start
       end
 
       def setup_connection_timeouts(conn)
-        # We use Timeout explicitly instead of this
-        conn.read_timeout = nil
+        conn.open_timeout = @request_timeout
+        conn.read_timeout = @request_timeout
+        # TODO: MAJOR VERSION - #write_timeout= requires Ruby 2.6+, so remove
+        #       the conditional check once support for Ruby 2.5 is dropped
+        conn.write_timeout = @request_timeout if conn.respond_to?(:write_timeout=)
 
         if conn.respond_to?(:keep_alive_timeout) && NewRelic::Agent.config[:aggressive_keepalive]
           conn.keep_alive_timeout = NewRelic::Agent.config[:keep_alive_timeout]
@@ -362,8 +369,8 @@ module NewRelic
         conn = create_http_connection
         start_connection(conn)
         conn
-      rescue Timeout::Error
-        ::NewRelic::Agent.logger.info("Timeout while attempting to connect. You may need to install system-level CA Certificates, as the ruby agent no longer includes these.")
+      rescue Net::OpenTimeout
+        ::NewRelic::Agent.logger.info('Timed out while attempting to connect. For SSL issues, you may need to install system-level CA Certificates to be used by Net::HTTP.')
         raise
       end
 
@@ -380,7 +387,7 @@ module NewRelic
         @marshaller.dump(data)
         true
       rescue StandardError, SystemStackError => e
-        NewRelic::Agent.logger.warn("Unable to marshal environment report on connect.", e)
+        NewRelic::Agent.logger.warn('Unable to marshal environment report on connect.', e)
         false
       end
 
@@ -409,7 +416,7 @@ module NewRelic
         end
         @audit_logger.log_request_headers(opts[:uri], headers)
         request['user-agent'] = user_agent
-        request.content_type = "application/octet-stream"
+        request.content_type = 'application/octet-stream'
         request.body = opts[:data]
         request
       end
@@ -436,13 +443,9 @@ module NewRelic
       end
 
       def attempt_request(request, opts)
-        response = nil
         conn = http_connection
         ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{opts[:uri]} with #{request.method}")
-        Timeout.timeout(@request_timeout) do
-          response = conn.request(request)
-        end
-        response
+        conn.request(request)
       end
 
       def handle_error_response(response, endpoint)
@@ -450,7 +453,9 @@ module NewRelic
         when Net::HTTPRequestTimeOut,
              Net::HTTPTooManyRequests,
              Net::HTTPInternalServerError,
-             Net::HTTPServiceUnavailable
+             Net::HTTPServiceUnavailable,
+             Net::OpenTimeout,
+             Net::ReadTimeout
           handle_server_connection_exception(response, endpoint)
         when Net::HTTPBadRequest,
              Net::HTTPForbidden,
@@ -462,7 +467,6 @@ module NewRelic
              Net::HTTPRequestURITooLong,
              Net::HTTPUnsupportedMediaType,
              Net::HTTPExpectationFailed,
-             Net::HTTPUnsupportedMediaType,
              Net::HTTPRequestHeaderFieldsTooLarge
           handle_unrecoverable_server_exception(response, endpoint)
         when Net::HTTPConflict,
@@ -472,9 +476,20 @@ module NewRelic
         when Net::HTTPGone
           handle_gone_response(response, endpoint)
         else
-          record_endpoint_attempts_supportability_metrics(endpoint)
-          record_error_response_supportability_metrics(response.code)
-          raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+          # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until
+          #       Ruby 2.6, so it can't be included in the case statement
+          #       as a constant and instead needs to be found here. Once
+          #       support for Ruby 2.5 is dropped, we should have
+          #       Net::WriteTimeout sit in the 'when' clause above alongside
+          #       Net::OpenTimeout and Net::ReadTimeout and this entire if/else
+          #       conditional can be removed.
+          if response.respond_to?(:name) && response.name == 'Net::WriteTimeout'
+            handle_server_connection_exception(response, endpoint)
+          else
+            record_endpoint_attempts_supportability_metrics(endpoint)
+            record_error_response_supportability_metrics(response.code)
+            raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+          end
         end
         response
       end
@@ -521,7 +536,7 @@ module NewRelic
           # ruled out; see the initializer
         }
 
-        uri = String.new('/agent_listener/invoke_raw_method?')
+        uri = +'/agent_listener/invoke_raw_method?'
         uri << params.map do |k, v|
           next unless v
 
@@ -551,7 +566,7 @@ module NewRelic
       end
 
       def handle_serialization_error(method, e)
-        NewRelic::Agent.increment_metric("Supportability/serialization_failure")
+        NewRelic::Agent.increment_metric('Supportability/serialization_failure')
         NewRelic::Agent.increment_metric("Supportability/serialization_failure/#{method}")
         msg = "Failed to serialize #{method} data using #{@marshaller.class}: #{e.inspect}"
         error = SerializationError.new(msg)
@@ -566,7 +581,7 @@ module NewRelic
           NewRelic::Agent.record_metric("Supportability/Agent/Collector/#{method}/Duration", request_duration)
         end
         if serialize_time
-          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
+          NewRelic::Agent.record_metric('Supportability/invoke_remote_serialize', serialize_time)
           NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method}", serialize_time)
         end
       end
@@ -581,7 +596,7 @@ module NewRelic
       # of items as arguments.
       def record_size_supportability_metrics(method, size_bytes, item_count)
         metrics = [
-          "Supportability/Ruby/Collector/Output/Bytes",
+          'Supportability/Ruby/Collector/Output/Bytes',
           "Supportability/Ruby/Collector/#{method}/Output/Bytes"
         ]
         # we may not have an item count, in which case, just record 0 for the exclusive time
@@ -595,7 +610,7 @@ module NewRelic
         return if post_string.size < Agent.config[:max_payload_size_in_bytes]
 
         ::NewRelic::Agent.logger.debug("Tried to send too much data: #{post_string.size} bytes")
-        NewRelic::Agent.increment_metric("Supportability/Agent/Collector/#{endpoint}/MaxPayloadSizeLimit")
+        NewRelic::Agent.increment_metric("Supportability/Ruby/Collector/#{endpoint}/MaxPayloadSizeLimit")
         raise UnrecoverableServerException.new('413 Request Entity Too Large')
       end
 

data/lib/new_relic/agent/obfuscator.rb

@@ -33,7 +33,7 @@ module NewRelic
       def encode(text)
         return text unless key_bytes
 
-        encoded = String.new('')
+        encoded = +''
         encoded.force_encoding('binary') if encoded.respond_to?(:force_encoding)
         index = 0
         text.each_byte do |byte|

data/lib/new_relic/agent/parameter_filtering.rb

@@ -7,7 +7,7 @@ module NewRelic
     module ParameterFiltering
       extend self
 
-      ACTION_DISPATCH_PARAMETER_FILTER ||= "action_dispatch.parameter_filter".freeze
+      ACTION_DISPATCH_PARAMETER_FILTER ||= 'action_dispatch.parameter_filter'.freeze
 
       if defined?(Rails) && Gem::Version.new(::Rails::VERSION::STRING) >= Gem::Version.new('5.0.0')
         Rails.application.config.to_prepare do
@@ -41,12 +41,12 @@ module NewRelic
       end
 
       def filter_rack_file_data(env, params)
-        content_type = env["CONTENT_TYPE"]
-        multipart = content_type && content_type.start_with?("multipart")
+        content_type = env['CONTENT_TYPE']
+        multipart = content_type&.start_with?('multipart')
 
         params.inject({}) do |memo, (k, v)|
           if multipart && v.is_a?(Hash) && v[:tempfile]
-            memo[k] = "[FILE]"
+            memo[k] = '[FILE]'
           else
             memo[k] = v
           end
@@ -56,8 +56,8 @@ module NewRelic
 
       def filter_rails_request_parameters(params)
         result = params.dup
-        result.delete("controller")
-        result.delete("action")
+        result.delete('controller')
+        result.delete('action')
         result
       end
 

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -55,7 +55,7 @@ module NewRelic
       # 4 GB - much larger than we'd ever need or want for this application.
       #
       class Pipe
-        READY_MARKER = "READY"
+        READY_MARKER = 'READY'
         NUM_LENGTH_BYTES = 4
 
         attr_accessor :in, :out
@@ -76,11 +76,11 @@ module NewRelic
         end
 
         def serialize_message_length(data)
-          [data.bytesize].pack("L>")
+          [data.bytesize].pack('L>')
         end
 
         def deserialize_message_length(data)
-          data.unpack("L>").first
+          data.unpack('L>').first
         end
 
         def write(data)
@@ -103,7 +103,7 @@ module NewRelic
               nil
             end
           else
-            NewRelic::Agent.logger.error("Failed to read bytes for length from pipe.")
+            NewRelic::Agent.logger.error('Failed to read bytes for length from pipe.')
             nil
           end
         end
@@ -218,7 +218,8 @@ module NewRelic
         def close_all_pipes
           @pipes_lock.synchronize do
             @pipes.each do |id, pipe|
-              pipe.close if pipe
+              # Needs else branch coverage
+              pipe.close if pipe # rubocop:disable Style/SafeNavigation
             end
             @pipes = {}
           end
@@ -255,7 +256,7 @@ module NewRelic
         def unmarshal(data)
           Marshal.load(data)
         rescue StandardError => e
-          ::NewRelic::Agent.logger.error("Failure unmarshalling message from Resque child process", e)
+          ::NewRelic::Agent.logger.error('Failure unmarshalling message from Resque child process', e)
           ::NewRelic::Agent.logger.debug(Base64.encode64(data))
           nil
         end

data/lib/new_relic/agent/pipe_service.rb

@@ -15,7 +15,7 @@ module NewRelic
         if @pipe && @pipe.parent_pid != $$
           @pipe.after_fork_in_child
         else
-          NewRelic::Agent.logger.error("No communication channel to parent process, please see https://newrelic.com/docs/ruby/resque-instrumentation for more information.")
+          NewRelic::Agent.logger.error('No communication channel to parent process, please see https://docs.newrelic.com/docs/apm/agents/ruby-agent/background-jobs/resque-instrumentation/ for more information.')
         end
       end
 
@@ -65,7 +65,8 @@ module NewRelic
       end
 
       def shutdown
-        @pipe.close if @pipe
+        # no else branch coverage
+        @pipe.close if @pipe # rubocop:disable Style/SafeNavigation
       end
 
       # Invokes the block it is passed.  This is used to implement HTTP
@@ -82,7 +83,8 @@ module NewRelic
       end
 
       def write_to_pipe(endpoint, data)
-        @pipe.write(marshal_payload([endpoint, data])) if @pipe
+        # the following line needs else branch coverage
+        @pipe.write(marshal_payload([endpoint, data])) if @pipe # rubocop:disable Style/SafeNavigation
       end
     end
   end

data/lib/new_relic/agent/priority_sampled_buffer.rb

@@ -8,7 +8,7 @@ require 'new_relic/agent/event_buffer'
 module NewRelic
   module Agent
     class PrioritySampledBuffer < EventBuffer
-      PRIORITY_KEY = "priority".freeze
+      PRIORITY_KEY = 'priority'.freeze
 
       attr_reader :seen_lifetime, :captured_lifetime
 

data/lib/new_relic/agent/rules_engine/segment_terms_rule.rb

@@ -11,7 +11,6 @@ module NewRelic
         SEGMENT_PLACEHOLDER = '*'.freeze
         ADJACENT_PLACEHOLDERS_REGEX = %r{((?:^|/)\*)(?:/\*)*}.freeze
         ADJACENT_PLACEHOLDERS_REPLACEMENT = '\1'.freeze
-        VALID_PREFIX_SEGMENT_COUNT = 2
 
         attr_reader :prefix, :terms
 

data/lib/new_relic/agent/rules_engine.rb

@@ -9,7 +9,7 @@ require 'new_relic/language_support'
 module NewRelic
   module Agent
     class RulesEngine
-      SEGMENT_SEPARATOR = '/'.freeze
+      SEGMENT_SEPARATOR = NewRelic::SLASH
       LEADING_SLASH_REGEX = %r{^/}.freeze
 
       include Enumerable

data/lib/new_relic/agent/sampler.rb

@@ -1,6 +1,7 @@
 # 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
+
 #
 # A Sampler is used to capture meaningful metrics in a background thread
 # periodically.  They will be invoked about once a minute, each time the agent
@@ -56,7 +57,7 @@ module NewRelic
       end
 
       def poll
-        raise "Implement in the subclass"
+        raise 'Implement in the subclass'
       end
     end
   end

data/lib/new_relic/agent/sampler_collection.rb

@@ -64,7 +64,7 @@ module NewRelic
       rescue NewRelic::Agent::Sampler::Unsupported => e
         ::NewRelic::Agent.logger.info("#{sampler_class.name} not available: #{e}")
       rescue => e
-        ::NewRelic::Agent.logger.error("Error registering sampler:", e)
+        ::NewRelic::Agent.logger.error('Error registering sampler:', e)
       end
     end
   end

data/lib/new_relic/agent/samplers/cpu_sampler.rb

@@ -16,26 +16,26 @@ module NewRelic
           @last_time = nil
           @processor_count = NewRelic::Agent::SystemInfo.num_logical_processors
           if @processor_count.nil?
-            NewRelic::Agent.logger.warn("Failed to determine processor count, assuming 1")
+            NewRelic::Agent.logger.warn('Failed to determine processor count, assuming 1')
             @processor_count = 1
           end
           poll
         end
 
         def record_user_util(value)
-          NewRelic::Agent.record_metric("CPU/User/Utilization", value)
+          NewRelic::Agent.record_metric('CPU/User/Utilization', value)
         end
 
         def record_system_util(value)
-          NewRelic::Agent.record_metric("CPU/System/Utilization", value)
+          NewRelic::Agent.record_metric('CPU/System/Utilization', value)
         end
 
         def record_usertime(value)
-          NewRelic::Agent.record_metric("CPU/User Time", value)
+          NewRelic::Agent.record_metric('CPU/User Time', value)
         end
 
         def record_systemtime(value)
-          NewRelic::Agent.record_metric("CPU/System Time", value)
+          NewRelic::Agent.record_metric('CPU/System Time', value)
         end
 
         def self.supported_on_this_platform?

data/lib/new_relic/agent/samplers/delayed_job_sampler.rb

@@ -21,21 +21,21 @@ module NewRelic
         # DelayedJob supports multiple backends, only some of which we can
         # handle. Check whether we think we've got what we need here.
         def self.supported_backend?
-          ::Delayed::Worker.backend.to_s == "Delayed::Backend::ActiveRecord::Job"
+          ::Delayed::Worker.backend.to_s == 'Delayed::Backend::ActiveRecord::Job'
         end
 
         def initialize
-          raise Unsupported, "DJ queue sampler disabled" if Agent.config[:disable_dj]
+          raise Unsupported, 'DJ queue sampler disabled' if Agent.config[:'instrumentation.delayed_job'] == 'disabled'
           raise Unsupported, "DJ queue sampling unsupported with backend '#{::Delayed::Worker.backend}'" unless self.class.supported_backend?
-          raise Unsupported, "No DJ worker present. Skipping DJ queue sampler" unless NewRelic::DelayedJobInjection.worker_name
+          raise Unsupported, 'No DJ worker present. Skipping DJ queue sampler' unless NewRelic::DelayedJobInjection.worker_name
         end
 
         def record_failed_jobs(value)
-          NewRelic::Agent.record_metric("Workers/DelayedJob/failed_jobs", value)
+          NewRelic::Agent.record_metric('Workers/DelayedJob/failed_jobs', value)
         end
 
         def record_locked_jobs(value)
-          NewRelic::Agent.record_metric("Workers/DelayedJob/locked_jobs", value)
+          NewRelic::Agent.record_metric('Workers/DelayedJob/locked_jobs', value)
         end
 
         FAILED_QUERY = 'failed_at is not NULL'.freeze
@@ -74,10 +74,10 @@ module NewRelic
 
         def record_queue_length_metrics
           counts = []
-          counts << record_counts_by("queue", "name") if ::Delayed::Job.instance_methods.include?(:queue)
-          counts << record_counts_by("priority")
+          counts << record_counts_by('queue', 'name') if ::Delayed::Job.instance_methods.include?(:queue)
+          counts << record_counts_by('priority')
 
-          all_metric = "Workers/DelayedJob/queue_length/all"
+          all_metric = 'Workers/DelayedJob/queue_length/all'
           NewRelic::Agent.record_metric(all_metric, counts.max)
         end
 
@@ -87,7 +87,7 @@ module NewRelic
           all_count = 0
           queue_counts(column_name).each do |column_val, count|
             all_count += count
-            column_val = "default" if column_val.nil? || column_val == NewRelic::EMPTY_STR
+            column_val = 'default' if column_val.nil? || column_val == NewRelic::EMPTY_STR
             metric = "Workers/DelayedJob/queue_length/#{metric_node}/#{column_val}"
             NewRelic::Agent.record_metric(metric, count)
           end

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -23,18 +23,18 @@ module NewRelic
             @sampler = ProcStatus.new
             if !@sampler.can_run?
               ::NewRelic::Agent.logger.debug("Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead.")
-              @sampler = ShellPS.new("ps -o rsz")
+              @sampler = ShellPS.new('ps -o rsz')
             else
               ::NewRelic::Agent.logger.debug("Using /proc/#{$$}/status for reading process memory.")
             end
           elsif platform.include?('darwin9') # 10.5
-            @sampler = ShellPS.new("ps -o rsz")
-          elsif platform =~ /darwin(1|2)\d+/ # >= 10.6
-            @sampler = ShellPS.new("ps -o rss")
+            @sampler = ShellPS.new('ps -o rsz')
+          elsif /darwin(1|2)\d+/.match?(platform) # >= 10.6
+            @sampler = ShellPS.new('ps -o rss')
           elsif platform.include?('freebsd')
-            @sampler = ShellPS.new("ps -o rss")
+            @sampler = ShellPS.new('ps -o rss')
           elsif platform.include?('solaris')
-            @sampler = ShellPS.new("/usr/bin/ps -o rss -p")
+            @sampler = ShellPS.new('/usr/bin/ps -o rss -p')
           end
 
           raise Unsupported, "Unsupported platform for getting memory: #{platform}" if @sampler.nil?
@@ -64,7 +64,7 @@ module NewRelic
         def poll
           sample = @sampler.get_sample
           if sample
-            NewRelic::Agent.record_metric("Memory/Physical", sample)
+            NewRelic::Agent.record_metric('Memory/Physical', sample)
           end
         end
 
@@ -106,7 +106,7 @@ module NewRelic
           end
 
           def to_s
-            "JRuby Java heap sampler"
+            'JRuby Java heap sampler'
           end
         end
 
@@ -140,7 +140,7 @@ module NewRelic
         class ProcStatus < Base
           # Returns the amount of resident memory this process is using in MB
           def get_memory
-            proc_status = File.open(proc_status_file, "r") { |f| f.read_nonblock(4096).strip }
+            proc_status = File.open(proc_status_file, 'r') { |f| f.read_nonblock(4096).strip }
             if proc_status =~ /RSS:\s*(\d+) kB/i
               return $1.to_f / 1024.0
             end

data/lib/new_relic/agent/samplers/object_sampler.rb

@@ -16,7 +16,7 @@ module NewRelic
 
         def poll
           live_objects = ObjectSpace.live_objects
-          NewRelic::Agent.record_metric("GC/objects", live_objects)
+          NewRelic::Agent.record_metric('GC/objects', live_objects)
         end
       end
     end

data/lib/new_relic/agent/span_event_aggregator.rb

@@ -18,7 +18,7 @@ module NewRelic
 
       def record(priority: nil, event: nil, &blk)
         unless event || priority && blk
-          raise ArgumentError, "Expected priority and block, or event"
+          raise ArgumentError, 'Expected priority and block, or event'
         end
 
         return unless enabled?
@@ -29,9 +29,9 @@ module NewRelic
         end
       end
 
-      SUPPORTABILITY_TOTAL_SEEN = "Supportability/SpanEvent/TotalEventsSeen".freeze
-      SUPPORTABILITY_TOTAL_SENT = "Supportability/SpanEvent/TotalEventsSent".freeze
-      SUPPORTABILITY_DISCARDED = "Supportability/SpanEvent/Discarded".freeze
+      SUPPORTABILITY_TOTAL_SEEN = 'Supportability/SpanEvent/TotalEventsSeen'.freeze
+      SUPPORTABILITY_TOTAL_SENT = 'Supportability/SpanEvent/TotalEventsSent'.freeze
+      SUPPORTABILITY_DISCARDED = 'Supportability/SpanEvent/Discarded'.freeze
 
       def after_harvest(metadata)
         seen = metadata[:seen]

data/lib/new_relic/agent/span_event_primitive.rb

@@ -29,16 +29,20 @@ module NewRelic
       CATEGORY_KEY = 'category'
       HTTP_URL_KEY = 'http.url'
       HTTP_METHOD_KEY = 'http.method'
+      HTTP_REQUEST_METHOD_KEY = 'http.request.method'
       HTTP_STATUS_CODE_KEY = 'http.statusCode'
       COMPONENT_KEY = 'component'
       DB_INSTANCE_KEY = 'db.instance'
       DB_STATEMENT_KEY = 'db.statement'
+      DB_SYSTEM_KEY = 'db.system'
       PEER_ADDRESS_KEY = 'peer.address'
       PEER_HOSTNAME_KEY = 'peer.hostname'
+      SERVER_ADDRESS_KEY = 'server.address'
+      SERVER_PORT_KEY = 'server.port'
       SPAN_KIND_KEY = 'span.kind'
       ENTRY_POINT_KEY = 'nr.entryPoint'
-      TRUSTED_PARENT_KEY = "trustedParentId"
-      TRACING_VENDORS_KEY = "tracingVendors"
+      TRUSTED_PARENT_KEY = 'trustedParentId'
+      TRACING_VENDORS_KEY = 'tracingVendors'
       TRANSACTION_NAME_KEY = 'transaction.name'
 
       # Strings for static values of the event structure
@@ -69,10 +73,12 @@ module NewRelic
 
         intrinsics[COMPONENT_KEY] = segment.library
         intrinsics[HTTP_METHOD_KEY] = segment.procedure
+        intrinsics[HTTP_REQUEST_METHOD_KEY] = segment.procedure
         intrinsics[HTTP_STATUS_CODE_KEY] = segment.http_status_code if segment.http_status_code
         intrinsics[CATEGORY_KEY] = HTTP_CATEGORY
         intrinsics[SPAN_KIND_KEY] = CLIENT
-
+        intrinsics[SERVER_ADDRESS_KEY] = segment.uri.host
+        intrinsics[SERVER_PORT_KEY] = segment.uri.port
         agent_attributes = error_attributes(segment) || {}
 
         if allowed?(HTTP_URL_KEY)
@@ -86,7 +92,7 @@ module NewRelic
         [intrinsics, custom_attributes(segment), agent_attributes]
       end
 
-      def for_datastore_segment(segment)
+      def for_datastore_segment(segment) # rubocop:disable Metrics/AbcSize
         intrinsics = intrinsics_for(segment)
 
         intrinsics[COMPONENT_KEY] = segment.product
@@ -101,9 +107,15 @@ module NewRelic
         if segment.host && segment.port_path_or_id && allowed?(PEER_ADDRESS_KEY)
           agent_attributes[PEER_ADDRESS_KEY] = truncate("#{segment.host}:#{segment.port_path_or_id}")
         end
-        if segment.host && allowed?(PEER_HOSTNAME_KEY)
-          agent_attributes[PEER_HOSTNAME_KEY] = truncate(segment.host)
+        if segment.host
+          [PEER_HOSTNAME_KEY, SERVER_ADDRESS_KEY].each do |key|
+            agent_attributes[key] = truncate(segment.host) if allowed?(key)
+          end
+        end
+        if segment.port_path_or_id&.match?(/^\d+$/) && allowed?(SERVER_PORT_KEY)
+          agent_attributes[SERVER_PORT_KEY] = segment.port_path_or_id
         end
+        agent_attributes[DB_SYSTEM_KEY] = segment.product if allowed?(DB_SYSTEM_KEY)
 
         if segment.sql_statement && allowed?(DB_STATEMENT_KEY)
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)

data/lib/new_relic/agent/sql_sampler.rb

@@ -154,12 +154,12 @@ module NewRelic
         end
       end
 
-      PRIORITY = "priority".freeze
+      PRIORITY = 'priority'.freeze
 
       def distributed_trace_attributes(state)
         transaction = state.current_transaction
         params = nil
-        if transaction && transaction.distributed_tracer.distributed_trace_payload
+        if transaction&.distributed_tracer&.distributed_trace_payload
           params = {}
           payload = transaction.distributed_tracer.distributed_trace_payload
           DistributedTraceAttributes.copy_from_transaction(transaction, payload, params)