newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -0,0 +1,157 @@
+# 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'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class Vendor
+        class << self
+          def vendor_name(vendor_name = nil)
+            vendor_name ? @vendor_name = vendor_name.freeze : @vendor_name
+          end
+
+          def endpoint(endpoint = nil)
+            endpoint ? @endpoint = URI(endpoint) : @endpoint
+          end
+
+          def headers(headers = nil)
+            headers ? @headers = headers.freeze : processed_headers
+          end
+
+          def keys(keys = nil)
+            keys ? @keys = keys.freeze : @keys
+          end
+
+          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
+
+        def initialize
+          @metadata = {}
+        end
+
+        [:vendor_name, :endpoint, :headers, :keys, :key_transforms].each do |method_name|
+          define_method(method_name) { self.class.send(method_name) }
+        end
+
+        SUCCESS = '200'.freeze
+
+        def detect
+          response = request_metadata
+          return false unless response
+
+          begin
+            if response.code == SUCCESS
+              process_response(prepare_response(response))
+            else
+              false
+            end
+          rescue => e
+            NewRelic::Agent.logger.error("Error occurred detecting: #{vendor_name}", e)
+            record_supportability_metric
+            false
+          end
+        end
+
+        private
+
+        def request_metadata
+          processed_headers = headers
+          raise if processed_headers.value?(:error)
+
+          response = nil
+          Net::HTTP.start(endpoint.host, endpoint.port, open_timeout: 1, read_timeout: 1) do |http|
+            req = Net::HTTP::Get.new(endpoint, processed_headers)
+            response = http.request(req)
+          end
+          response
+        rescue
+          NewRelic::Agent.logger.debug("#{vendor_name} environment not detected")
+        end
+
+        def prepare_response(response)
+          JSON.parse(response.body)
+        end
+
+        def process_response(response)
+          keys.each do |key|
+            normalized = normalize(response[key])
+            if normalized
+              @metadata[transform_key(key)] = normalized
+            else
+              @metadata.clear
+              record_supportability_metric
+              return false
+            end
+          end
+          true
+        end
+
+        def normalize(value)
+          return if value.nil?
+
+          value = value.to_s
+          value = value.dup if value.frozen?
+
+          value.force_encoding(Encoding::UTF_8)
+          value.strip!
+
+          return unless valid_length?(value)
+          return unless valid_chars?(value)
+
+          value
+        end
+
+        def valid_length?(value)
+          if value.bytesize <= 255
+            true
+          else
+            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)
+          value.each_char do |ch|
+            next if VALID_CHARS.match?(ch)
+
+            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}")
+            return false # it's in neither set of valid characters
+          end
+          true
+        end
+
+        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")
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization_data.rb

@@ -1,23 +1,34 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/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
 
-      REMOTE_DATA_VALID_CHARS = /^[0-9a-zA-Z_ .\/-]$/.freeze
+      VENDORS = {
+        Utilization::AWS => :'utilization.detect_aws',
+        Utilization::GCP => :'utilization.detect_gcp',
+        Utilization::Azure => :'utilization.detect_azure',
+        Utilization::PCF => :'utilization.detect_pcf'
+      }
 
-      def harvest!
-        [hostname, container_id, cpu_count, instance_type]
+      def hostname
+        NewRelic::Agent::Hostname.get
       end
 
-      # No persistent data, so no need for merging or resetting
-      def merge!(*_); end
-      def reset!(*_); end
+      def fqdn
+        NewRelic::Agent::Hostname.get_fqdn
+      end
 
-      def hostname
-        NewRelic::Agent::Hostname.get
+      def ip_addresses
+        ::NewRelic::Agent::SystemInfo.ip_addresses
       end
 
       def container_id
@@ -29,49 +40,125 @@ module NewRelic
         ::NewRelic::Agent::SystemInfo.num_logical_processors
       end
 
-      def instance_type
-        Timeout::timeout(1) do
-          remote_fetch('instance-type')
+      def ram_in_mib
+        ::NewRelic::Agent::SystemInfo.ram_in_mib
+      end
+
+      def configured_hostname
+        Agent.config[:'utilization.billing_hostname']
+      end
+
+      # this is slightly ugly, but if a string value is passed in
+      # for the env var: NEW_RELIC_UTILIZATION_LOGICAL_PROCESSORS the
+      # coercion from EnvironmentSource will turn that into a numerical 0,
+      # which is not a reasonable value for logical_processes and should
+      # not be sent up
+      def configured_logical_processors
+        logical_processors = Agent.config[:'utilization.logical_processors']
+        logical_processors unless logical_processors == 0
+      end
+
+      # see comment above as the situation is the same for:
+      # NEW_RELIC_UTILIZATION_TOTAL_RAM_MIB
+      def configured_total_ram_mib
+        total_ram = Agent.config[:'utilization.total_ram_mib']
+        total_ram unless total_ram == 0
+      end
+
+      def to_collector_hash
+        result = {
+          :metadata_version => METADATA_VERSION,
+          :logical_processors => cpu_count,
+          :total_ram_mib => ram_in_mib,
+          :hostname => hostname
+        }
+
+        append_vendor_info(result)
+        append_docker_info(result)
+        append_configured_values(result)
+        append_boot_id(result)
+        append_ip_address(result)
+        append_full_hostname(result)
+        append_kubernetes_info(result)
+
+        result
+      end
+
+      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
+            collector_hash[:vendors] ||= {}
+            collector_hash[:vendors][vendor.vendor_name.to_sym] = vendor.metadata
+            break
+          end
         end
-      rescue Timeout::Error
-        NewRelic::Agent.logger.debug("UtilizationData timed out fetching remote keys.")
-        nil
-      rescue StandardError, LoadError => e
-        NewRelic::Agent.logger.debug("UtilizationData encountered error fetching remote keys:\n#{e}")
-        nil
       end
 
-      INSTANCE_HOST = '169.254.169.254'
-      API_VERSION   = '2008-02-01'
+      def append_docker_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_docker']
 
-      def remote_fetch(remote_key)
-        uri = URI("http://#{INSTANCE_HOST}/#{API_VERSION}/meta-data/#{remote_key}")
-        request = Net::HTTP::get(uri)
+        if docker_container_id = container_id
+          collector_hash[:vendors] ||= {}
+          collector_hash[:vendors][:docker] = {:id => docker_container_id}
+        end
+      end
 
-        data = validate_remote_data(request)
+      def append_configured_values(collector_hash)
+        collector_hash[:config] = config_hash unless config_hash.empty?
+      end
 
-        if request && data.nil?
-          NewRelic::Agent.logger.warn("Fetching instance metadata for #{remote_key.inspect} returned invalid data: #{request.inspect}")
+      def append_boot_id(collector_hash)
+        if bid = ::NewRelic::Agent::SystemInfo.boot_id
+          collector_hash[:boot_id] = bid
         end
+      end
 
-        data
+      def append_ip_address(collector_hash)
+        ips = ip_addresses
+        collector_hash[:ip_address] = ips unless ips.empty?
       end
 
-      def validate_remote_data(data_str)
-        return nil unless data_str.kind_of?(String)
-        return nil unless data_str.size <= 255
+      KUBERNETES_SERVICE_HOST = 'KUBERNETES_SERVICE_HOST'.freeze
 
-        data_str.each_char do |ch|
-          next if ch =~ REMOTE_DATA_VALID_CHARS
-          code_point = ch[0].ord # this works in Ruby 1.8.7 - 2.1.2
-          next if code_point >= 0x80
+      def append_kubernetes_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_kubernetes']
 
-          return nil # it's in neither set of valid characters
+        if host = ENV[KUBERNETES_SERVICE_HOST]
+          collector_hash[:vendors] ||= {}
+          collector_hash[:vendors][:kubernetes] = {
+            kubernetes_service_host: host
+          }
         end
+      end
+
+      def append_full_hostname(collector_hash)
+        full_hostname = fqdn
+        return if full_hostname.nil? || full_hostname.empty?
 
-        data_str
+        collector_hash[:full_hostname] = full_hostname
       end
 
+      def config_hash
+        config_hash = {}
+
+        if hostname = configured_hostname
+          config_hash[:hostname] = hostname
+        end
+
+        if logical_processors = configured_logical_processors
+          config_hash[:logical_processors] = logical_processors
+        end
+
+        if total_ram_mib = configured_total_ram_mib
+          config_hash[:total_ram_mib] = total_ram_mib
+        end
+
+        config_hash
+      end
     end
   end
 end

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

@@ -0,0 +1,99 @@
+# 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'
+
+module NewRelic
+  module Agent
+    module VM
+      class CRubyVM
+        def snapshot
+          snap = Snapshot.new
+          gather_stats(snap)
+          snap
+        end
+
+        def gather_stats(snap)
+          gather_gc_stats(snap)
+          gather_ruby_vm_stats(snap)
+          gather_thread_stats(snap)
+          gather_gc_time(snap)
+        end
+
+        def gather_gc_stats(snap)
+          gather_gc_runs(snap) if supports?(:gc_runs)
+          gather_derived_stats(snap)
+        end
+
+        def gather_gc_runs(snap)
+          snap.gc_runs = GC.count
+        end
+
+        def gather_derived_stats(snap)
+          stat = GC.stat
+          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)
+          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)
+            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)
+          snap.thread_count = Thread.list.size
+        end
+
+        def supports?(key)
+          case key
+          when :gc_runs,
+            :total_allocated_object,
+            :heap_live,
+            :heap_free,
+            :thread_count,
+            :major_gc_count,
+            :minor_gc_count,
+            :constant_cache_invalidations
+            true
+          when :gc_total_time
+            NewRelic::LanguageSupport.gc_profiler_enabled?
+          when :method_cache_invalidations
+            RUBY_VERSION < '3.0.0'
+          when :constant_cache_misses
+            RUBY_VERSION >= '3.2.0'
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+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'
@@ -26,9 +26,7 @@ module NewRelic
 
         def supports?(key)
           case key
-          when :gc_runs
-            RUBY_VERSION >= "1.9.2"
-          when :thread_count
+          when :gc_runs, :thread_count
             true
           else
             false

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
@@ -34,7 +34,7 @@ module NewRelic
             end
           else
             NewRelic::Agent.logger.log_once(:warn, :gc_profiler_disabled,
-              "Tried to measure GC time, but GC::Profiler was not enabled.")
+              'Tried to measure GC time, but GC::Profiler was not enabled.')
           end
 
           @total_time_s

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,11 +1,10 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/language_support'
-require 'new_relic/agent/vm/mri_vm'
+require 'new_relic/agent/vm/c_ruby_vm'
 require 'new_relic/agent/vm/jruby_vm'
-require 'new_relic/agent/vm/rubinius_vm'
 
 module NewRelic
   module Agent
@@ -19,12 +18,10 @@ module NewRelic
       end
 
       def self.create_vm
-        if NewRelic::LanguageSupport.using_engine?('jruby')
+        if NewRelic::LanguageSupport.jruby?
           JRubyVM.new
-        elsif NewRelic::LanguageSupport.using_engine?('rbx')
-          RubiniusVM.new
         else
-          MriVM.new
+          CRubyVM.new
         end
       end
     end

data/lib/new_relic/agent/worker_loop.rb

@@ -1,28 +1,28 @@
-# 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] if opts[:duration]
-        @limit = opts[:limit] if opts[:limit]
+        @duration = opts[:duration]
+        @limit = opts[:limit]
         @iterations = 0
         @propagate_errors = opts.fetch(:propagate_errors, false)
+        @deadline = nil
       end
 
       # Reset state that is changed by running the worker loop
@@ -32,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
@@ -40,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?
@@ -51,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
@@ -64,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?
@@ -76,9 +76,7 @@ module NewRelic
         @should_run = false
       end
 
-      # Executes the block given to the worker loop, and handles many
-      # possible errors. Also updates the execution time so that the
-      # next run occurs on schedule, even if we execute at some odd time
+      # Executes the block given to the worker loop, and handles errors.
       def run_task
         if @propagate_errors
           @task.call
@@ -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