newrelic_rpm 6.10.0.364 → 8.15.0

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/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/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/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/utilization/vendor'
 
@@ -9,15 +9,16 @@ 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/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 'net/http'
 
@@ -9,25 +9,35 @@ 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
-            headers ? @headers = headers.freeze : @headers
+          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
+
+          def processed_headers
+            return unless @headers
+
+            @headers.each_with_object({}) do |(key, value), processed_hash|
+              # Header lambdas are expected to return string values. If nil comes back, replace it with :error
+              # to signify that the call failed.
+              processed_hash[key] = value.class.eql?(Proc) ? value.call || :error : value
+            end
+          end
         end
 
         attr_reader :metadata
@@ -48,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
@@ -62,25 +72,28 @@ module NewRelic
         private
 
         def request_metadata
-          Timeout.timeout 1 do
+          processed_headers = headers
+          raise if processed_headers.value?(:error)
+
+          Timeout.timeout(1) do
             response = nil
-            Net::HTTP.start endpoint.host, endpoint.port do |http|
-              req = Net::HTTP::Get.new endpoint, 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
@@ -92,51 +105,53 @@ 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,23 +1,22 @@
-# 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/utilization/aws'
 require 'new_relic/agent/utilization/gcp'
 require 'new_relic/agent/utilization/azure'
 require 'new_relic/agent/utilization/pcf'
 
-
 module NewRelic
   module Agent
     class UtilizationData
       METADATA_VERSION = 5
 
       VENDORS = {
-        Utilization::AWS   => :'utilization.detect_aws',
-        Utilization::GCP   => :'utilization.detect_gcp',
+        Utilization::AWS => :'utilization.detect_aws',
+        Utilization::GCP => :'utilization.detect_gcp',
         Utilization::Azure => :'utilization.detect_azure',
-        Utilization::PCF   => :'utilization.detect_pcf'
+        Utilization::PCF => :'utilization.detect_pcf'
       }
 
       def hostname
@@ -88,6 +87,7 @@ module NewRelic
       def append_vendor_info(collector_hash)
         VENDORS.each_pair do |klass, config_option|
           next unless Agent.config[config_option]
+
           vendor = klass.new
 
           if vendor.detect
@@ -126,6 +126,7 @@ module NewRelic
 
       def append_kubernetes_info(collector_hash)
         return unless Agent.config[:'utilization.detect_kubernetes']
+
         if host = ENV[KUBERNETES_SERVICE_HOST]
           collector_hash[:vendors] ||= {}
           collector_hash[:vendors][:kubernetes] = {
@@ -137,6 +138,7 @@ module NewRelic
       def append_full_hostname(collector_hash)
         full_hostname = fqdn
         return if full_hostname.nil? || full_hostname.empty?
+
         collector_hash[:full_hostname] = full_hostname
       end
 

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/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 '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/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
 
 # 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
@@ -16,7 +16,7 @@ module NewRelic
       class MonotonicGCProfiler
         def initialize
           @total_time_s = 0
-          @lock         = Mutex.new
+          @lock = Mutex.new
         end
 
         def total_time_s

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/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 'thread'
 require 'new_relic/agent/vm/snapshot'
@@ -23,32 +23,57 @@ 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
 
-          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_gc_runs(snap)
+          snap.gc_runs = GC.count
+        end
+
+        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)
           if supports?(:method_cache_invalidations)
-            vm_stats = RubyVM.stat
-            snap.method_cache_invalidations = vm_stats[:global_method_state]
-            snap.constant_cache_invalidations = vm_stats[:global_constant_state]
+            snap.method_cache_invalidations = RubyVM.stat[:global_method_state]
           end
+
+          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
+          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)
@@ -66,9 +91,11 @@ module NewRelic
           when :minor_gc_count
             RUBY_VERSION >= '2.1.0'
           when :method_cache_invalidations
-            RUBY_VERSION >= '2.1.0'
+            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,18 +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
 
 module NewRelic
   module Agent
     module VM
       class Snapshot
         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
+          :total_allocated_object, :heap_live, :heap_free,
+          :method_cache_invalidations, :constant_cache_invalidations,
+          :constant_cache_misses, :thread_count, :taken_at
 
         def initialize
-          @taken_at = Time.now.to_f
+          @taken_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
       end
     end

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/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/language_support'
 require 'new_relic/agent/vm/mri_vm'

data/lib/new_relic/agent/worker_loop.rb

@@ -1,24 +1,22 @@
-# 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 'thread'
 
 module NewRelic
   module Agent
-
     # A worker loop executes a set of registered tasks on a single thread.
     # A task is a proc or block with a specified call period in seconds.
     class WorkerLoop
-
       attr_accessor :period, :propagate_errors
       attr_reader :iterations
 
       # Optional argument :duration (in seconds) for how long the worker loop runs
       # or :limit (integer) for max number of iterations
-      def initialize(opts={})
+      def initialize(opts = {})
         @should_run = true
-        @next_invocation_time = Time.now
+        @next_invocation_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @period = 60.0
         @duration = opts[:duration]
         @limit = opts[:limit]
@@ -34,7 +32,7 @@ module NewRelic
         @should_run = true
         @iterations = 0
 
-        now = Time.now
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         @deadline = now + @duration if @duration
         @next_invocation_time = (now + @period)
       end
@@ -42,9 +40,9 @@ module NewRelic
       # Run infinitely, calling the registered tasks at their specified
       # call periods.  The caller is responsible for creating the thread
       # that runs this worker loop.  This will run the task immediately.
-      def run(period=nil, &block)
+      def run(period = nil, &block)
         setup(period, block)
-        while keep_running? do
+        while keep_running?
           sleep_time = schedule_next_invocation
           sleep(sleep_time) if sleep_time > 0
           run_task if keep_running?
@@ -53,11 +51,11 @@ module NewRelic
       end
 
       def schedule_next_invocation
-        now = Time.now
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         while @next_invocation_time <= now && @period > 0
           @next_invocation_time += @period
         end
-        @next_invocation_time - Time.now
+        @next_invocation_time - Process.clock_gettime(Process::CLOCK_REALTIME)
       end
 
       # a simple accessor for @should_run
@@ -66,7 +64,7 @@ module NewRelic
       end
 
       def under_duration?
-        !@deadline || Time.now < @deadline
+        !@deadline || Process.clock_gettime(Process::CLOCK_REALTIME) < @deadline
       end
 
       def under_limit?
@@ -90,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