newrelic_rpm 8.7.0 → 8.11.0

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
 
 # This module powers the Busy calculation for the Capacity report in
 # APM (https://rpm.newrelic.com/accounts/.../applications/.../optimize/capacity_analysis).
@@ -12,13 +12,13 @@
 module NewRelic
   module Agent
     module TransactionTimeAggregator
-      TransactionStats = Struct.new :transaction_started_at, :elapsed_transaction_time
+      TransactionStats = Struct.new(:transaction_started_at, :elapsed_transaction_time)
 
       @lock = Mutex.new
       @harvest_cycle_started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
 
       @stats = Hash.new do |h, k|
-        h[k] = TransactionStats.new nil, 0.0
+        h[k] = TransactionStats.new(nil, 0.0)
       end
 
       def reset!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
@@ -28,14 +28,14 @@ module NewRelic
 
       def transaction_start(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         @lock.synchronize do
-          set_transaction_start_time timestamp
+          set_transaction_start_time(timestamp)
         end
       end
 
       def transaction_stop(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), starting_thread_id = current_thread)
         @lock.synchronize do
-          record_elapsed_transaction_time_until timestamp, starting_thread_id
-          set_transaction_start_time nil, starting_thread_id
+          record_elapsed_transaction_time_until(timestamp, starting_thread_id)
+          set_transaction_start_time(nil, starting_thread_id)
         end
       end
 
@@ -100,23 +100,23 @@ module NewRelic
         end
 
         def thread_is_alive?(thread_id)
-          thread = thread_by_id thread_id
+          thread = thread_by_id(thread_id)
           thread && thread.alive?
         rescue StandardError
           false
         end
 
         # ObjectSpace is faster on MRI, but disabled by default on JRuby for
-        # perfomance reasons. We have two implmentations of `thread_by_id`
+        # performance reasons. We have two implementations of `thread_by_id`
         # based on ruby implementation.
         if RUBY_ENGINE == 'jruby'
-          def thread_by_id thread_id
+          def thread_by_id(thread_id)
             Thread.list.detect { |t| t.object_id == thread_id }
           end
         else
           require 'objspace'
 
-          def thread_by_id thread_id
+          def thread_by_id(thread_id)
             ObjectSpace._id2ref(thread_id)
           end
         end
@@ -131,14 +131,14 @@ module NewRelic
           @stats[thread_id].elapsed_transaction_time = 0.0
         end
 
-        def transaction_time_in_thread timestamp, thread_id, entry
-          return entry.elapsed_transaction_time unless in_transaction? thread_id
+        def transaction_time_in_thread(timestamp, thread_id, entry)
+          return entry.elapsed_transaction_time unless in_transaction?(thread_id)
 
           # Count the portion of the transaction that's elapsed so far,...
-          elapsed = record_elapsed_transaction_time_until timestamp, thread_id
+          elapsed = record_elapsed_transaction_time_until(timestamp, thread_id)
 
           # ...then readjust the transaction start time to the next harvest
-          split_transaction_at_harvest timestamp, thread_id
+          split_transaction_at_harvest(timestamp, thread_id)
 
           elapsed
         end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/utilization/vendor'
 
@@ -25,15 +25,15 @@ module NewRelic
               '',
               {'X-aws-ec2-metadata-token-ttl-seconds' => IMDS_TOKEN_TTL_SECS})
             unless response.code == Vendor::SUCCESS
-              NewRelic::Agent.logger.debug 'Failed to obtain an AWS token for use with IMDS - encountered ' \
+              NewRelic::Agent.logger.debug('Failed to obtain an AWS token for use with IMDS - encountered ' \
                                            "#{response.class} with HTTP response code #{response.code} - " \
-                                           'assuming non AWS'
+                                           'assuming non AWS')
               return
             end
 
             response.body
           rescue Net::OpenTimeout
-            NewRelic::Agent.logger.debug 'Timed out waiting for AWS IMDS - assuming non AWS'
+            NewRelic::Agent.logger.debug('Timed out waiting for AWS IMDS - assuming non AWS')
           end
         end
 

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
@@ -9,7 +9,7 @@ module NewRelic
         vendor_name "azure"
         endpoint "http://169.254.169.254/metadata/instance/compute?api-version=2017-03-01"
         headers "Metadata" => "true"
-        keys ["vmId", "name", "vmSize", "location"]
+        keys %w[vmId name vmSize location]
         key_transforms :to_sym
       end
     end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/utilization/vendor'
 
@@ -11,22 +11,22 @@ module NewRelic
         vendor_name "gcp"
         endpoint "http://metadata.google.internal/computeMetadata/v1/instance/?recursive=true"
         headers "Metadata-Flavor" => "Google"
-        keys ["id", "machineType", "name", "zone"]
+        keys %w[id machineType name zone]
         key_transforms :to_sym
 
         MACH_TYPE = 'machineType'.freeze
         ZONE = 'zone'.freeze
 
-        def prepare_response response
-          body = JSON.parse response.body
-          body[MACH_TYPE] = trim_leading body[MACH_TYPE]
-          body[ZONE] = trim_leading body[ZONE]
+        def prepare_response(response)
+          body = JSON.parse(response.body)
+          body[MACH_TYPE] = trim_leading(body[MACH_TYPE])
+          body[ZONE] = trim_leading(body[ZONE])
           body
         end
 
         SLASH = '/'.freeze
 
-        def trim_leading value
+        def trim_leading(value)
           value.split(SLASH).last
         end
       end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/utilization/vendor'
 
@@ -9,15 +9,15 @@ module NewRelic
     module Utilization
       class PCF < Vendor
         vendor_name "pcf"
-        keys ["CF_INSTANCE_GUID", "CF_INSTANCE_IP", "MEMORY_LIMIT"]
+        keys %w[CF_INSTANCE_GUID CF_INSTANCE_IP MEMORY_LIMIT]
         key_transforms [:downcase, :to_sym]
 
         def detect
           begin
             return false unless pcf_keys_present?
-            process_response ENV
+            process_response(ENV)
           rescue
-            NewRelic::Agent.logger.error "Error occurred detecting: #{vendor_name}", e
+            NewRelic::Agent.logger.error("Error occurred detecting: #{vendor_name}", e)
             record_supportability_metric
             false
           end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'net/http'
 
@@ -9,23 +9,23 @@ module NewRelic
     module Utilization
       class Vendor
         class << self
-          def vendor_name vendor_name = nil
+          def vendor_name(vendor_name = nil)
             vendor_name ? @vendor_name = vendor_name.freeze : @vendor_name
           end
 
-          def endpoint endpoint = nil
+          def endpoint(endpoint = nil)
             endpoint ? @endpoint = URI(endpoint) : @endpoint
           end
 
-          def headers headers = nil
+          def headers(headers = nil)
             headers ? @headers = headers.freeze : processed_headers
           end
 
-          def keys keys = nil
+          def keys(keys = nil)
             keys ? @keys = keys.freeze : @keys
           end
 
-          def key_transforms key_transforms = nil
+          def key_transforms(key_transforms = nil)
             key_transforms ? @key_transforms = Array(key_transforms).freeze : @key_transforms
           end
 
@@ -58,12 +58,12 @@ module NewRelic
 
           begin
             if response.code == SUCCESS
-              process_response prepare_response(response)
+              process_response(prepare_response(response))
             else
               false
             end
           rescue => e
-            NewRelic::Agent.logger.error "Error occurred detecting: #{vendor_name}", e
+            NewRelic::Agent.logger.error("Error occurred detecting: #{vendor_name}", e)
             record_supportability_metric
             false
           end
@@ -73,27 +73,27 @@ module NewRelic
 
         def request_metadata
           processed_headers = headers
-          raise if processed_headers.values.include?(:error)
+          raise if processed_headers.value?(:error)
 
-          Timeout.timeout 1 do
+          Timeout.timeout(1) do
             response = nil
-            Net::HTTP.start endpoint.host, endpoint.port do |http|
-              req = Net::HTTP::Get.new endpoint, processed_headers
-              response = http.request req
+            Net::HTTP.start(endpoint.host, endpoint.port) do |http|
+              req = Net::HTTP::Get.new(endpoint, processed_headers)
+              response = http.request(req)
             end
             response
           end
         rescue
-          NewRelic::Agent.logger.debug "#{vendor_name} environment not detected"
+          NewRelic::Agent.logger.debug("#{vendor_name} environment not detected")
         end
 
-        def prepare_response response
-          JSON.parse response.body
+        def prepare_response(response)
+          JSON.parse(response.body)
         end
 
-        def process_response response
+        def process_response(response)
           keys.each do |key|
-            normalized = normalize response[key]
+            normalized = normalize(response[key])
             if normalized
               @metadata[transform_key(key)] = normalized
             else
@@ -105,51 +105,51 @@ module NewRelic
           true
         end
 
-        def normalize value
+        def normalize(value)
           return if value.nil?
 
           value = value.to_s
           value = value.dup if value.frozen?
 
-          value.force_encoding Encoding::UTF_8
+          value.force_encoding(Encoding::UTF_8)
           value.strip!
 
-          return unless valid_length? value
-          return unless valid_chars? value
+          return unless valid_length?(value)
+          return unless valid_chars?(value)
 
           value
         end
 
-        def valid_length? value
+        def valid_length?(value)
           if value.bytesize <= 255
             true
           else
-            NewRelic::Agent.logger.warn "Found invalid length value while detecting: #{vendor_name}"
+            NewRelic::Agent.logger.warn("Found invalid length value while detecting: #{vendor_name}")
             false
           end
         end
 
         VALID_CHARS = /^[0-9a-zA-Z_ .\/-]$/
 
-        def valid_chars? value
+        def valid_chars?(value)
           value.each_char do |ch|
             next if ch =~ VALID_CHARS
             code_point = ch[0].ord # this works in Ruby 1.8.7 - 2.1.2
             next if code_point >= 0x80
 
-            NewRelic::Agent.logger.warn "Found invalid character while detecting: #{vendor_name}"
+            NewRelic::Agent.logger.warn("Found invalid character while detecting: #{vendor_name}")
             return false # it's in neither set of valid characters
           end
           true
         end
 
-        def transform_key key
+        def transform_key(key)
           return key unless key_transforms
           key_transforms.inject(key) { |memo, transform| memo.send(transform) }
         end
 
         def record_supportability_metric
-          NewRelic::Agent.increment_metric "Supportability/utilization/#{vendor_name}/error"
+          NewRelic::Agent.increment_metric("Supportability/utilization/#{vendor_name}/error")
         end
       end
     end

data/lib/new_relic/agent/utilization_data.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/utilization/aws'
 require 'new_relic/agent/utilization/gcp'

data/lib/new_relic/agent/vm/jruby_vm.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'thread'
 require 'new_relic/agent/vm/snapshot'

data/lib/new_relic/agent/vm/monotonic_gc_profiler.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
 
 # The GC::Profiler class available on MRI has to be reset periodically to avoid
 # memory "leaking" in the underlying implementation. However, it's a major

data/lib/new_relic/agent/vm/mri_vm.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'thread'
 require 'new_relic/agent/vm/snapshot'
@@ -23,24 +23,35 @@ module NewRelic
         end
 
         def gather_gc_stats(snap)
-          if supports?(:gc_runs)
-            snap.gc_runs = GC.count
-          end
+          gather_gc_runs(snap) if supports?(:gc_runs)
+          gather_derived_stats(snap) if GC.respond_to?(:stat)
+        end
+
+        def gather_gc_runs(snap)
+          snap.gc_runs = GC.count
+        end
 
-          if GC.respond_to?(:stat)
-            gc_stats = GC.stat
-            snap.total_allocated_object = gc_stats[:total_allocated_objects] || gc_stats[:total_allocated_object]
-            snap.major_gc_count = gc_stats[:major_gc_count]
-            snap.minor_gc_count = gc_stats[:minor_gc_count]
-            snap.heap_live = gc_stats[:heap_live_slots] || gc_stats[:heap_live_slot] || gc_stats[:heap_live_num]
-            snap.heap_free = gc_stats[:heap_free_slots] || gc_stats[:heap_free_slot] || gc_stats[:heap_free_num]
+        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
         end
 
         def gather_gc_time(snap)
-          if supports?(:gc_total_time)
-            snap.gc_total_time = NewRelic::Agent.instance.monotonic_gc_profiler.total_time_s
-          end
+          return unless supports?(:gc_total_time)
+
+          snap.gc_total_time = NewRelic::Agent.instance.monotonic_gc_profiler.total_time_s
         end
 
         def gather_ruby_vm_stats(snap)
@@ -51,18 +62,18 @@ module NewRelic
           if supports?(:constant_cache_invalidations)
             snap.constant_cache_invalidations = gather_constant_cache_invalidations
           end
+
+          if supports?(:constant_cache_misses)
+            snap.constant_cache_misses = gather_constant_cache_misses
+          end
         end
 
         def gather_constant_cache_invalidations
-          # Ruby >= 3.2 uses :constant_cache
-          # see: https://github.com/ruby/ruby/pull/5433 and https://bugs.ruby-lang.org/issues/18589
-          # TODO: now that 3.2+ provides more granual cache invalidation data, should we report it instead of summing?
-          if RUBY_VERSION >= '3.2.0'
-            RubyVM.stat[:constant_cache].values.sum
-          # Ruby < 3.2 uses :global_constant_state
-          else
-            RubyVM.stat[:global_constant_state]
-          end
+          RubyVM.stat[RUBY_VERSION >= '3.2.0' ? :constant_cache_invalidations : :global_constant_state]
+        end
+
+        def gather_constant_cache_misses
+          RubyVM.stat[:constant_cache_misses]
         end
 
         def gather_thread_stats(snap)
@@ -83,6 +94,8 @@ module NewRelic
             RUBY_VERSION >= '2.1.0' && RUBY_VERSION < '3.0.0'
           when :constant_cache_invalidations
             RUBY_VERSION >= '2.1.0'
+          when :constant_cache_misses
+            RUBY_VERSION >= '3.2.0'
           else
             false
           end

data/lib/new_relic/agent/vm/snapshot.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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
@@ -9,7 +9,7 @@ module NewRelic
         attr_accessor :gc_total_time, :gc_runs, :major_gc_count, :minor_gc_count,
           :total_allocated_object, :heap_live, :heap_free,
           :method_cache_invalidations, :constant_cache_invalidations,
-          :thread_count, :taken_at
+          :constant_cache_misses, :thread_count, :taken_at
 
         def initialize
           @taken_at = Process.clock_gettime(Process::CLOCK_REALTIME)

data/lib/new_relic/agent/vm.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/language_support'
 require 'new_relic/agent/vm/mri_vm'

data/lib/new_relic/agent/worker_loop.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'thread'
 
@@ -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