newrelic_rpm 9.5.0 → 9.7.0

data/lib/new_relic/agent/new_relic_service/encoders.rb

@@ -2,10 +2,10 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
 require 'json'
 require 'stringio'
 require 'zlib'
+require 'new_relic/base64'
 
 module NewRelic
   module Agent
@@ -45,7 +45,7 @@ module NewRelic
               data = NewRelic::Agent::EncodingNormalizer.normalize_object(data)
             end
             json = ::JSON.dump(data)
-            Base64.encode64(Compressed::Deflate.encode(json))
+            NewRelic::Base64.encode64(Compressed::Deflate.encode(json))
           end
         end
       end

data/lib/new_relic/agent/new_relic_service.rb

@@ -414,7 +414,7 @@ module NewRelic
         else
           request = Net::HTTP::Post.new(opts[:uri], headers)
         end
-        @audit_logger.log_request_headers(opts[:uri], headers)
+        @audit_logger.log_request_headers(filtered_uri(opts[:uri]), headers)
         request['user-agent'] = user_agent
         request.content_type = 'application/octet-stream'
         request.body = opts[:data]
@@ -431,7 +431,7 @@ module NewRelic
         rescue *CONNECTION_ERRORS => e
           close_shared_connection
           if attempts < MAX_ATTEMPTS
-            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
+            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{filtered_uri(opts[:uri])} after #{e}")
             retry
           else
             raise ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
@@ -444,7 +444,7 @@ module NewRelic
 
       def attempt_request(request, opts)
         conn = http_connection
-        ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{opts[:uri]} with #{request.method}")
+        ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{filtered_uri(opts[:uri])} with #{request.method}")
         conn.request(request)
       end
 
@@ -689,9 +689,7 @@ module NewRelic
 
       def invoke_remote_send_request(method, payload, data, encoding)
         uri = remote_method_uri(method)
-        full_uri = "#{@collector}#{uri}"
-
-        @audit_logger.log_request(full_uri, payload, @marshaller)
+        @audit_logger.log_request("#{@collector}#{filtered_uri(uri)}", payload, @marshaller)
         request_send_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         response = send_request(:data => data,
           :uri       => uri,
@@ -700,6 +698,10 @@ module NewRelic
           :endpoint  => method)
         [response, request_send_ts, Process.clock_gettime(Process::CLOCK_MONOTONIC)]
       end
+
+      def filtered_uri(uri)
+        uri.gsub(license_key, ASTERISK * license_key.size)
+      end
     end
   end
 end

data/lib/new_relic/agent/obfuscator.rb

@@ -2,8 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-# require 'base64'
-
 module NewRelic
   module Agent
     class Obfuscator

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -2,7 +2,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
+require 'new_relic/base64'
 
 module NewRelic
   module Agent
@@ -257,7 +257,7 @@ module NewRelic
           Marshal.load(data)
         rescue StandardError => e
           ::NewRelic::Agent.logger.error('Failure unmarshalling message from Resque child process', e)
-          ::NewRelic::Agent.logger.debug(Base64.encode64(data))
+          ::NewRelic::Agent.logger.debug(NewRelic::Base64.encode64(data))
           nil
         end
 

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

@@ -8,7 +8,6 @@ module NewRelic
       class SegmentTermsRule
         PREFIX_KEY = 'prefix'.freeze
         TERMS_KEY = 'terms'.freeze
-        SEGMENT_PLACEHOLDER = '*'.freeze
         ADJACENT_PLACEHOLDERS_REGEX = %r{((?:^|/)\*)(?:/\*)*}.freeze
         ADJACENT_PLACEHOLDERS_REPLACEMENT = '\1'.freeze
 
@@ -52,7 +51,7 @@ module NewRelic
           rest = string[@trim_range]
           leading_slash = rest.slice!(LEADING_SLASH_REGEX)
           segments = rest.split(SEGMENT_SEPARATOR, -1)
-          segments.map! { |s| @terms.include?(s) ? s : SEGMENT_PLACEHOLDER }
+          segments.map! { |s| @terms.include?(s) ? s : ASTERISK }
           transformed_suffix = collapse_adjacent_placeholder_segments(segments)
 
           "#{@prefix}#{leading_slash}#{transformed_suffix}"

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/span_event_primitive.rb

@@ -29,12 +29,16 @@ 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'
@@ -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

@@ -3,7 +3,6 @@
 # frozen_string_literal: true
 
 require 'zlib'
-require 'base64'
 require 'digest/md5'
 
 module NewRelic

data/lib/new_relic/agent/system_info.rb

@@ -13,6 +13,8 @@ require 'socket'
 module NewRelic
   module Agent
     module SystemInfo
+      DOCKER_CGROUPS_V2_PATTERN = %r{.*/docker/containers/([0-9a-f]{64})/.*}.freeze
+
       def self.ruby_os_identifier
         RbConfig::CONFIG['target_os']
       end
@@ -172,15 +174,39 @@ module NewRelic
         proc_try_read('/proc/version')
       end
 
+      # When operating within a Docker container, attempt to obtain the
+      # container id.
+      #
+      # First look for `/proc/self/mountinfo` to exist on disk to signify
+      # cgroups v2. If that file exists, read it and expect it to contain one
+      # or more "/docker/containers/<container_id>/" lines from which the
+      # container id can be gleaned.
+      #
+      # Next look for `/proc/self/cgroup` to exist on disk to signify cgroup v1.
+      # If that file exists, read it and parse the "cpu" group info in the hope
+      # of finding a 64 character container id value.
+      #
+      # For non-cgroups based containers, use a `nil` value for the container
+      # id without generating any warnings or errors.
       def self.docker_container_id
         return unless ruby_os_identifier.include?('linux')
 
+        cgroupsv2_based_id = docker_container_id_for_cgroupsv2
+        return cgroupsv2_based_id if cgroupsv2_based_id
+
         cgroup_info = proc_try_read('/proc/self/cgroup')
         return unless cgroup_info
 
         parse_docker_container_id(cgroup_info)
       end
 
+      def self.docker_container_id_for_cgroupsv2
+        mountinfo = proc_try_read('/proc/self/mountinfo')
+        return unless mountinfo
+
+        Regexp.last_match(1) if mountinfo =~ DOCKER_CGROUPS_V2_PATTERN
+      end
+
       def self.parse_docker_container_id(cgroup_info)
         cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
         return unless cpu_cgroup

data/lib/new_relic/agent/tracer.rb

@@ -357,9 +357,7 @@ module NewRelic
           yield
         rescue => exception
           # needs else branch coverage
-          if segment && segment.is_a?(Transaction::AbstractSegment) # rubocop:disable Style/SafeNavigation
-            segment.notice_error(exception)
-          end
+          segment.notice_error(exception) if segment&.is_a?(Transaction::AbstractSegment)
           raise
         end
 
@@ -420,16 +418,17 @@ module NewRelic
           NewRelic::Agent.config[:'instrumentation.thread.tracing']
         end
 
-        def thread_block_with_current_transaction(segment_name:, parent: nil, &block)
+        def thread_block_with_current_transaction(segment_name: nil, parent: nil, &block)
           parent ||= current_segment
           current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
           proc do |*args|
             begin
               if current_txn && !current_txn.finished?
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn
+                ::Thread.current[:newrelic_thread_span_parent] = parent
                 current_txn.async = true
-                segment_name += "/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
-                segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent)
+                segment_name = "#{segment_name}/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
+                segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent) if segment_name
               end
               NewRelic::Agent::Tracer.capture_segment_error(segment) do
                 yield(*args)

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -338,6 +338,9 @@ module NewRelic
 
           NewRelic::Agent.logger.debug("Invoking callback for #{self.class.name}...")
           self.class.instance_variable_get(CALLBACK).call
+        rescue Exception => e
+          NewRelic::Agent.logger.error("Error encountered while invoking callback for #{self.class.name}: " +
+                                       "#{e.class} - #{e.message}")
         end
 
         # Setting and invoking a segment callback

data/lib/new_relic/agent/transaction/external_request_segment.rb

@@ -14,6 +14,7 @@ module NewRelic
       # @api public
       class ExternalRequestSegment < Segment
         NR_SYNTHETICS_HEADER = 'X-NewRelic-Synthetics'
+        NR_SYNTHETICS_INFO_HEADER = 'X-NewRelic-Synthetics-Info'
         APP_DATA_KEY = 'NewRelicAppData'
 
         EXTERNAL_ALL = 'External/all'
@@ -63,7 +64,8 @@ module NewRelic
         def add_request_headers(request)
           process_host_header(request)
           synthetics_header = transaction&.raw_synthetics_header
-          insert_synthetics_header(request, synthetics_header) if synthetics_header
+          synthetics_info_header = transaction&.raw_synthetics_info_header
+          insert_synthetics_header(request, synthetics_header, synthetics_info_header) if synthetics_header
 
           return unless record_metrics?
 
@@ -207,8 +209,9 @@ module NewRelic
           end
         end
 
-        def insert_synthetics_header(request, header)
+        def insert_synthetics_header(request, header, info)
           request[NR_SYNTHETICS_HEADER] = header
+          request[NR_SYNTHETICS_INFO_HEADER] = info if info
         end
 
         def segment_complete

data/lib/new_relic/agent/transaction/message_broker_segment.rb

@@ -15,7 +15,6 @@ module NewRelic
         PRODUCE = 'Produce'.freeze
         QUEUE = 'Queue'.freeze
         PURGE = 'Purge'.freeze
-        SLASH = '/'.freeze
         TEMP = 'Temp'.freeze
         TOPIC = 'Topic'.freeze
         UNKNOWN = 'Unknown'.freeze
@@ -73,7 +72,7 @@ module NewRelic
           return @name if @name
 
           @name = METRIC_PREFIX + library
-          @name << SLASH << TYPES[destination_type] << SLASH << ACTIONS[action] << SLASH
+          @name << NewRelic::SLASH << TYPES[destination_type] << NewRelic::SLASH << ACTIONS[action] << NewRelic::SLASH
 
           if destination_type == :temporary_queue || destination_type == :temporary_topic
             @name << TEMP

data/lib/new_relic/agent/transaction/request_attributes.rb

@@ -103,12 +103,10 @@ module NewRelic
         # rails construct the PATH_INFO enviroment variable improperly and we're generally
         # being defensive.
 
-        ROOT_PATH = '/'.freeze
-
         def path_from_request(request)
           path = attribute_from_request(request, :path) || ''
           path = HTTPClients::URIUtil.strip_query_string(path)
-          path.empty? ? ROOT_PATH : path
+          path.empty? ? NewRelic::ROOT : path
         end
 
         def content_length_from_request(request)

data/lib/new_relic/agent/transaction/tracing.rb

@@ -22,7 +22,7 @@ module NewRelic
 
         def add_segment(segment, parent = nil)
           segment.transaction = self
-          segment.parent = parent || current_segment
+          segment.parent = parent || thread_starting_span || current_segment
           set_current_segment(segment)
           if @segments.length < segment_limit
             @segments << segment
@@ -39,6 +39,16 @@ module NewRelic
           segment.transaction_assigned
         end
 
+        def thread_starting_span
+          # if the previous current segment was in another thread, use the thread local parent
+          if ::Thread.current[:newrelic_thread_span_parent] &&
+              current_segment &&
+              current_segment.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
+
+            ::Thread.current[:newrelic_thread_span_parent]
+          end
+        end
+
         def segment_complete(segment)
           # if parent was in another thread, remove the current_segment entry for this thread
           if segment.parent && segment.parent.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key

data/lib/new_relic/agent/transaction.rb

@@ -90,7 +90,7 @@ module NewRelic
       attr_reader :transaction_trace
 
       # Fields for tracking synthetics requests
-      attr_accessor :raw_synthetics_header, :synthetics_payload
+      attr_accessor :raw_synthetics_header, :synthetics_payload, :synthetics_info_payload, :raw_synthetics_info_header
 
       # Return the currently active transaction, or nil.
       def self.tl_current
@@ -520,7 +520,7 @@ module NewRelic
       end
 
       def finish
-        return unless state.is_execution_traced?
+        return unless state.is_execution_traced? && initial_segment
 
         @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @duration = @end_time - @start_time
@@ -623,11 +623,24 @@ module NewRelic
           attributes.add_intrinsic_attribute(:synthetics_resource_id, synthetics_resource_id)
           attributes.add_intrinsic_attribute(:synthetics_job_id, synthetics_job_id)
           attributes.add_intrinsic_attribute(:synthetics_monitor_id, synthetics_monitor_id)
+          attributes.add_intrinsic_attribute(:synthetics_type, synthetics_info('type'))
+          attributes.add_intrinsic_attribute(:synthetics_initiator, synthetics_info('initiator'))
+
+          synthetics_additional_attributes do |key, value|
+            attributes.add_intrinsic_attribute(key, value)
+          end
         end
 
         distributed_tracer.assign_intrinsics
       end
 
+      def synthetics_additional_attributes(&block)
+        synthetics_info('attributes')&.each do |k, v|
+          new_key = "synthetics_#{NewRelic::LanguageSupport.snakeize(k.to_s)}".to_sym
+          yield(new_key, v.to_s)
+        end
+      end
+
       def calculate_gc_time
         gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
         NewRelic::Agent::StatsEngine::GCProfiler.record_delta(gc_start_snapshot, gc_stop_snapshot)
@@ -707,6 +720,10 @@ module NewRelic
         info[4]
       end
 
+      def synthetics_info(key)
+        synthetics_info_payload[key] if synthetics_info_payload
+      end
+
       def append_apdex_perf_zone(payload)
         if recording_web_transaction?
           bucket = apdex_bucket(duration, apdex_t)
@@ -730,6 +747,12 @@ module NewRelic
         payload[:synthetics_resource_id] = synthetics_resource_id
         payload[:synthetics_job_id] = synthetics_job_id
         payload[:synthetics_monitor_id] = synthetics_monitor_id
+        payload[:synthetics_type] = synthetics_info('type')
+        payload[:synthetics_initiator] = synthetics_info('initiator')
+
+        synthetics_additional_attributes do |key, value|
+          payload[key] = value
+        end
       end
 
       def merge_metrics

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -31,9 +31,14 @@ module NewRelic
       SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'.freeze
       SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'.freeze
       SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'.freeze
+      SYNTHETICS_TYPE_KEY = 'nr.syntheticsType'
+      SYNTHETICS_INITIATOR_KEY = 'nr.syntheticsInitiator'
+      SYNTHETICS_KEY_PREFIX = 'nr.synthetics'
       PRIORITY_KEY = 'priority'.freeze
       SPAN_ID_KEY = 'spanId'.freeze
 
+      SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
+
       def create(noticed_error, payload, span_id)
         [
           intrinsic_attributes_for(noticed_error, payload, span_id),
@@ -71,9 +76,20 @@ module NewRelic
       end
 
       def append_synthetics(payload, sample)
+        return unless payload[:synthetics_job_id]
+
         sample[SYNTHETICS_RESOURCE_ID_KEY] = payload[:synthetics_resource_id] if payload[:synthetics_resource_id]
         sample[SYNTHETICS_JOB_ID_KEY] = payload[:synthetics_job_id] if payload[:synthetics_job_id]
         sample[SYNTHETICS_MONITOR_ID_KEY] = payload[:synthetics_monitor_id] if payload[:synthetics_monitor_id]
+        sample[SYNTHETICS_TYPE_KEY] = payload[:synthetics_type] if payload[:synthetics_type]
+        sample[SYNTHETICS_INITIATOR_KEY] = payload[:synthetics_initiator] if payload[:synthetics_initiator]
+
+        payload.each do |k, v|
+          next unless k.to_s.start_with?('synthetics_') && !SYNTHETICS_PAYLOAD_EXPECTED.include?(k)
+
+          new_key = SYNTHETICS_KEY_PREFIX + NewRelic::LanguageSupport.camelize(k.to_s.gsub('synthetics_', ''))
+          sample[new_key] = v
+        end
       end
 
       def append_cat(payload, sample)

data/lib/new_relic/agent/transaction_event_primitive.rb

@@ -38,6 +38,11 @@ module NewRelic
       SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'
       SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'
       SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'
+      SYNTHETICS_TYPE_KEY = 'nr.syntheticsType'
+      SYNTHETICS_INITIATOR_KEY = 'nr.syntheticsInitiator'
+      SYNTHETICS_KEY_PREFIX = 'nr.synthetics'
+
+      SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
 
       def create(payload)
         intrinsics = {
@@ -71,9 +76,23 @@ module NewRelic
         optionally_append(SYNTHETICS_RESOURCE_ID_KEY, :synthetics_resource_id, sample, payload)
         optionally_append(SYNTHETICS_JOB_ID_KEY, :synthetics_job_id, sample, payload)
         optionally_append(SYNTHETICS_MONITOR_ID_KEY, :synthetics_monitor_id, sample, payload)
+        optionally_append(SYNTHETICS_TYPE_KEY, :synthetics_type, sample, payload)
+        optionally_append(SYNTHETICS_INITIATOR_KEY, :synthetics_initiator, sample, payload)
+        append_synthetics_info_attributes(sample, payload)
         append_cat_alternate_path_hashes(sample, payload)
       end
 
+      def append_synthetics_info_attributes(sample, payload)
+        return unless payload.include?(:synthetics_job_id)
+
+        payload.each do |k, v|
+          next unless k.to_s.start_with?('synthetics_') && !SYNTHETICS_PAYLOAD_EXPECTED.include?(k)
+
+          new_key = SYNTHETICS_KEY_PREFIX + NewRelic::LanguageSupport.camelize(k.to_s.gsub('synthetics_', ''))
+          sample[new_key] = v.to_s
+        end
+      end
+
       def append_cat_alternate_path_hashes(sample, payload)
         if payload.include?(:cat_alternate_path_hashes)
           sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(COMMA)

data/lib/new_relic/agent/utilization/gcp.rb

@@ -24,10 +24,8 @@ module NewRelic
           body
         end
 
-        SLASH = '/'.freeze
-
         def trim_leading(value)
-          value.split(SLASH).last
+          value.split(NewRelic::SLASH).last
         end
       end
     end

data/lib/new_relic/agent/vm/{mri_vm.rb → c_ruby_vm.rb}

@@ -8,7 +8,7 @@ require 'new_relic/agent/vm/snapshot'
 module NewRelic
   module Agent
     module VM
-      class MriVM
+      class CRubyVM
         def snapshot
           snap = Snapshot.new
           gather_stats(snap)
@@ -24,7 +24,7 @@ module NewRelic
 
         def gather_gc_stats(snap)
           gather_gc_runs(snap) if supports?(:gc_runs)
-          gather_derived_stats(snap) if GC.respond_to?(:stat)
+          gather_derived_stats(snap)
         end
 
         def gather_gc_runs(snap)
@@ -33,19 +33,11 @@ module NewRelic
 
         def gather_derived_stats(snap)
           stat = GC.stat
-          snap.total_allocated_object = derive_from_gc_stats(%i[total_allocated_objects total_allocated_object], stat)
-          snap.major_gc_count = derive_from_gc_stats(:major_gc_count, stat)
-          snap.minor_gc_count = derive_from_gc_stats(:minor_gc_count, stat)
-          snap.heap_live = derive_from_gc_stats(%i[heap_live_slots heap_live_slot heap_live_num], stat)
-          snap.heap_free = derive_from_gc_stats(%i[heap_free_slots heap_free_slot heap_free_num], stat)
-        end
-
-        def derive_from_gc_stats(keys, stat)
-          Array(keys).each do |key|
-            value = stat[key]
-            return value if value
-          end
-          nil
+          snap.total_allocated_object = stat.fetch(:total_allocated_objects, nil)
+          snap.major_gc_count = stat.fetch(:major_gc_count, nil)
+          snap.minor_gc_count = stat.fetch(:minor_gc_count, nil)
+          snap.heap_live = stat.fetch(:heap_live_slots, nil)
+          snap.heap_free = stat.fetch(:heap_free_slots, nil)
         end
 
         def gather_gc_time(snap)

data/lib/new_relic/agent/vm.rb

@@ -3,7 +3,7 @@
 # frozen_string_literal: true
 
 require 'new_relic/language_support'
-require 'new_relic/agent/vm/mri_vm'
+require 'new_relic/agent/vm/c_ruby_vm'
 require 'new_relic/agent/vm/jruby_vm'
 
 module NewRelic
@@ -21,7 +21,7 @@ module NewRelic
         if NewRelic::LanguageSupport.jruby?
           JRubyVM.new
         else
-          MriVM.new
+          CRubyVM.new
         end
       end
     end

data/lib/new_relic/agent/worker_loop.rb

@@ -88,7 +88,7 @@ module NewRelic
             raise
           rescue => e
             # Don't blow out the stack for anything that hasn't already propagated
-            ::NewRelic::Agent.logger.error('Error running task in Agent Worker Loop:', e)
+            ::NewRelic::Agent.logger.error('Error running task in agent worker loop:', e)
           end
         end
       end

data/lib/new_relic/agent.rb

@@ -252,7 +252,7 @@ module NewRelic
 
     # @!group Recording custom errors
 
-    # Set a filter to be applied to errors that the Ruby Agent will
+    # Set a filter to be applied to errors that the Ruby agent will
     # track.  The block should evaluate to the exception to track
     # (which could be different from the original exception) or nil to
     # ignore this exception.
@@ -391,13 +391,13 @@ module NewRelic
 
     # @!group Manual agent configuration and startup/shutdown
 
-    # Call this to manually start the Agent in situations where the Agent does
+    # Call this to manually start the agent in situations where the agent does
     # not auto-start.
     #
-    # When the app environment loads, so does the Agent. However, the
-    # Agent will only connect to the service if a web front-end is found. If
+    # When the app environment loads, so does the agent. However, the
+    # agent will only connect to the service if a web front-end is found. If
     # you want to selectively monitor ruby processes that don't use
-    # web plugins, then call this method in your code and the Agent
+    # web plugins, then call this method in your code and the agent
     # will fire up and start reporting to the service.
     #
     # Options are passed in as overrides for values in the
@@ -633,7 +633,9 @@ module NewRelic
     def add_new_segment_attributes(params, segment)
       # Make sure not to override existing segment-level custom attributes
       segment_custom_keys = segment.attributes.custom_attributes.keys.map(&:to_sym)
-      segment.add_custom_attributes(params.reject { |k, _v| segment_custom_keys.include?(k.to_sym) })
+      segment.add_custom_attributes(params.reject do |k, _v|
+        segment_custom_keys.include?(k.to_sym) if k.respond_to?(:to_sym) # param keys can be integers
+      end)
     end
 
     # Add custom attributes to the span event for the current span. Attributes will be visible on spans in the
@@ -661,7 +663,9 @@ module NewRelic
       end
     end
 
-    # Add custom attributes to log events for the current agent instance.
+    # Add global custom attributes to log events for the current agent instance. As these attributes are global to the
+    # agent instance, they will be attached to all log events generated by the agent, and this methods usage isn't
+    # suitable for setting dynamic values.
     #
     # @param [Hash] params    A Hash of attributes to attach to log
     #                         events. The agent accepts up to 240 custom