newrelic_rpm 6.3.0.355 → 9.2.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/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
 
 # This module powers the Busy calculation for the Capacity report in
 # APM (https://rpm.newrelic.com/accounts/.../applications/.../optimize/capacity_analysis).
@@ -12,36 +12,36 @@
 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 = Time.now
+      @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 = Time.now)
+      def reset!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         @harvest_cycle_started_at = timestamp
         @stats.clear
       end
 
-      def transaction_start(timestamp = Time.now)
+      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 = Time.now, starting_thread_id = current_thread)
+      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
 
       INSTANCE_BUSY_METRIC = 'Instance/Busy'.freeze
 
-      def harvest!(timestamp = Time.now)
+      def harvest!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         active_threads = 0
         result = @lock.synchronize do
           # Sum up the transaction times spent in each thread
@@ -50,7 +50,7 @@ module NewRelic
           end
 
           active_threads = @stats.size
-          elapsed_harvest_time      = (timestamp - @harvest_cycle_started_at) * active_threads
+          elapsed_harvest_time = (timestamp - @harvest_cycle_started_at) * active_threads
           @harvest_cycle_started_at = timestamp
 
           # Clear out the stats for all threads, _except_ the live ones
@@ -75,9 +75,9 @@ module NewRelic
       end
 
       module_function :reset!,
-                      :transaction_start,
-                      :transaction_stop,
-                      :harvest!
+        :transaction_start,
+        :transaction_stop,
+        :harvest!
 
       class << self
         private
@@ -100,23 +100,24 @@ module NewRelic
         end
 
         def thread_is_alive?(thread_id)
-          thread = thread_by_id thread_id
-          thread && thread.alive?
+          thread = thread_by_id(thread_id)
+          # needs else branch coverage
+          thread && thread.alive? # rubocop:disable Style/SafeNavigation
         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
@@ -127,26 +128,30 @@ module NewRelic
 
         def split_transaction_at_harvest(timestamp, thread_id = nil)
           raise ArgumentError, 'thread_id required' unless thread_id
+
           @stats[thread_id].transaction_started_at = timestamp
           @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
 
+        # this method has no test coverage
         def log_missing_elapsed_transaction_time
-          transaction_name = Tracer.current_transaction &&
+          # rubocop:disable Style/SafeNavigation
+          transaction_name = transaction_name = Tracer.current_transaction &&
             Tracer.current_transaction.best_name ||
-              "unknown"
+            'unknown'
+          # rubocop:enable Style/SafeNavigation
           NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
         end
       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/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'
 
@@ -8,9 +8,39 @@ module NewRelic
   module Agent
     module Utilization
       class AWS < Vendor
-        vendor_name "aws"
-        endpoint "http://169.254.169.254/2016-09-02/dynamic/instance-identity/document"
-        keys ["instanceId", "instanceType", "availabilityZone"]
+        IMDS_BASE_URL = 'http://169.254.169.254/latest'.freeze
+        IMDS_KEYS = %w[instanceId instanceType availabilityZone].freeze
+        IMDS_TOKEN_TTL_SECS = '60'.freeze
+        TOKEN_OPEN_TIMEOUT_SECS = 1.freeze
+        TOKEN_READ_TIMEOUT_SECS = 1.freeze
+
+        class << self
+          def imds_token
+            uri = URI.parse("#{IMDS_BASE_URL}/api/token")
+            http = Net::HTTP.new(uri.hostname)
+            http.open_timeout = TOKEN_OPEN_TIMEOUT_SECS
+            http.read_timeout = TOKEN_READ_TIMEOUT_SECS
+            response = http.send_request('PUT',
+              uri.path,
+              '',
+              {'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 ' \
+                                           "#{response.class} with HTTP response code #{response.code} - " \
+                                           'assuming non AWS')
+              return
+            end
+
+            response.body
+          rescue Net::OpenTimeout
+            NewRelic::Agent.logger.debug('Timed out waiting for AWS IMDS - assuming non AWS')
+          end
+        end
+
+        vendor_name 'aws'
+        endpoint "#{IMDS_BASE_URL}/dynamic/instance-identity/document"
+        keys IMDS_KEYS
+        headers 'X-aws-ec2-metadata-token' => -> { imds_token }
         key_transforms :to_sym
       end
     end

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

@@ -1,17 +1,17 @@
-# 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 Utilization
       class Azure < Vendor
-        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"]
+        vendor_name 'azure'
+        endpoint 'http://169.254.169.254/metadata/instance/compute?api-version=2017-03-01'
+        headers 'Metadata' => 'true'
+        keys %w[vmId name vmSize location]
         key_transforms :to_sym
       end
     end
   end
-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/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'
 
@@ -8,25 +8,25 @@ module NewRelic
   module Agent
     module Utilization
       class GCP < Vendor
-        vendor_name "gcp"
-        endpoint "http://metadata.google.internal/computeMetadata/v1/instance/?recursive=true"
-        headers "Metadata-Flavor" => "Google"
-        keys ["id", "machineType", "name", "zone"]
+        vendor_name 'gcp'
+        endpoint 'http://metadata.google.internal/computeMetadata/v1/instance/?recursive=true'
+        headers 'Metadata-Flavor' => 'Google'
+        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'
 
@@ -8,16 +8,17 @@ module NewRelic
   module Agent
     module Utilization
       class PCF < Vendor
-        vendor_name "pcf"
-        keys ["CF_INSTANCE_GUID", "CF_INSTANCE_IP", "MEMORY_LIMIT"]
+        vendor_name 'pcf'
+        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
+            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}"
+            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
@@ -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/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
+
+        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)
           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)
@@ -57,18 +82,21 @@ module NewRelic
 
         def supports?(key)
           case key
-          when :gc_runs, :total_allocated_object, :heap_live, :heap_free, :thread_count
+          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 :major_gc_count
-            RUBY_VERSION >= '2.1.0'
-          when :minor_gc_count
-            RUBY_VERSION >= '2.1.0'
           when :method_cache_invalidations
-            RUBY_VERSION >= '2.1.0'
-          when :constant_cache_invalidations
-            RUBY_VERSION >= '2.1.0'
+            RUBY_VERSION < '3.0.0'
+          when :constant_cache_misses
+            RUBY_VERSION >= '3.2.0'
           else
             false
           end