newrelic_rpm 6.15.0 → 8.13.1

data/lib/new_relic/control/instance_methods.rb

@@ -1,18 +1,20 @@
-# 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/null_logger'
 require 'new_relic/agent/memory_logger'
 require 'new_relic/agent/agent_logger'
 
+require_relative 'private_instance_methods'
+
 module NewRelic
   class Control
-
     # Contains methods that relate to the runtime usage of the control
     # object. Note that these are subject to override in the
     # NewRelic::Control::Framework classes that are actually instantiated
     module InstanceMethods
+      include PrivateInstanceMethods
       # The env is the setting used to identify which section of the newrelic.yml
       # to load.  This defaults to a framework specific value, such as ENV['RAILS_ENV']
       # but can be overridden as long as you set it before calling #init_plugin
@@ -47,15 +49,13 @@ module NewRelic
       # Subclasses are not allowed to override, but must implement
       # init_config({}) which is called one or more times.
       #
-      def init_plugin(options={})
+      def init_plugin(options = {})
         env = determine_env(options)
 
         configure_agent(env, options)
 
         # Be sure to only create once! RUBY-1020
-        if ::NewRelic::Agent.logger.is_startup_logger?
-          ::NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new(root, options.delete(:log))
-        end
+        create_logger(options)
 
         # Merge the stringified options into the config as overrides:
         environment_name = options.delete(:env) and self.env = environment_name
@@ -64,21 +64,11 @@ module NewRelic
 
         # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
         # methods in the module methods.
-        Module.send :include, NewRelic::Agent::MethodTracer::ClassMethods
-        Module.send :include, NewRelic::Agent::MethodTracer
+        Module.send(:include, NewRelic::Agent::MethodTracer::ClassMethods)
+        Module.send(:include, NewRelic::Agent::MethodTracer)
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
-
-        if !security_settings_valid?
-          handle_invalid_security_settings
-        elsif Agent.config[:agent_enabled] && !NewRelic::Agent.instance.started?
-          start_agent
-          install_instrumentation
-        elsif !Agent.config[:agent_enabled]
-          install_shim
-        else
-          DependencyDetection.detect!
-        end
+        init_instrumentation
       end
 
       def determine_env(options)
@@ -86,11 +76,13 @@ module NewRelic
         env = env.to_s
 
         if @started_in_env && @started_in_env != env
-          Agent.logger.error("Attempted to start agent in #{env.inspect} environment, but agent was already running in #{@started_in_env.inspect}",
-                             "The agent will continue running in #{@started_in_env.inspect}. To alter this, ensure the desired environment is set before the agent starts.")
+          Agent.logger.error("Attempted to start agent in #{env.inspect} environment, but agent was already running " \
+            "in #{@started_in_env.inspect}", "The agent will continue running in #{@started_in_env.inspect}. To " \
+            "alter this, ensure the desired environment is set before the agent starts.")
         else
-          Agent.logger.info("Starting the New Relic agent version #{NewRelic::VERSION::STRING} in #{env.inspect} environment.",
-                            "To prevent agent startup add a NEW_RELIC_AGENT_ENABLED=false environment variable or modify the #{env.inspect} section of your newrelic.yml.")
+          Agent.logger.info("Starting the New Relic agent version #{NewRelic::VERSION::STRING} in #{env.inspect} " \
+            "environment.", "To prevent agent startup add a NEW_RELIC_AGENT_ENABLED=false environment variable or " \
+            "modify the #{env.inspect} section of your newrelic.yml.")
         end
 
         env
@@ -99,33 +91,20 @@ module NewRelic
       def configure_agent(env, options)
         manual = Agent::Configuration::ManualSource.new(options)
         Agent.config.replace_or_add_config(manual)
-
-        config_file_path = @config_file_override || Agent.config[:config_path]
         yaml_source = Agent::Configuration::YamlSource.new(config_file_path, env)
-        if yaml_source.failed?
-          yaml_source.failures.each do |msg|
-            stdout.puts Agent::AgentLogger.format_fatal_error(msg)
-          end
-        end
+        log_yaml_source_failures(yaml_source) if yaml_source.failed?
         Agent.config.replace_or_add_config(yaml_source)
-
-        if security_settings_valid? && Agent.config[:high_security]
-          Agent.logger.info("Installing high security configuration based on local configuration")
-          Agent.config.replace_or_add_config(Agent::Configuration::HighSecuritySource.new(Agent.config))
-        end
+        configure_high_security
       end
 
       def security_settings_valid?
-        !Agent.config[:high_security] ||
-          Agent.config[:security_policies_token].empty?
+        !Agent.config[:high_security] || Agent.config[:security_policies_token].empty?
       end
 
       def handle_invalid_security_settings
-        NewRelic::Agent.logger.error "Security Policies and High Security " \
-          "Mode cannot both be present in the agent configuration. If " \
-          "Security Policies have been set for your account, please " \
-          "ensure the security_policies_token is set but high_security is " \
-          "disabled (default)."
+        NewRelic::Agent.logger.error("Security Policies and High Security Mode cannot both be present in the agent " \
+          "configuration. If Security Policies have been set for your account, please ensure the " \
+          "security_policies_token is set but high_security is disabled (default).")
         install_shim
       end
 
@@ -164,13 +143,12 @@ module NewRelic
 
       protected
 
-      def initialize(local_env, config_file_override=nil)
+      def initialize(local_env, config_file_override = nil)
+        @install_lock = Mutex.new
         @local_env = local_env
         @started_in_env = nil
-
         @instrumented = nil
         @instrumentation_files = []
-
         @config_file_override = config_file_override
       end
 

data/lib/new_relic/control/instrumentation.rb

@@ -1,24 +1,23 @@
-# 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
   class Control
     # Contains methods that relate to adding and executing files that
     # contain instrumentation for the Ruby Agent
     module Instrumentation
-
       # Adds a list of files in Dir.glob format
       # (e.g. '/app/foo/**/*_instrumentation.rb')
       # This requires the files within a rescue block, so that any
       # errors within instrumentation files do not affect the overall
       # agent or application in which it runs.
-      def load_instrumentation_files pattern
+      def load_instrumentation_files(pattern)
         Dir.glob(pattern) do |file|
           begin
             require file.to_s
           rescue => e
-            ::NewRelic::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
+            ::NewRelic::Agent.logger.warn("Error loading instrumentation file '#{file}':", e)
           end
         end
       end
@@ -34,9 +33,9 @@ module NewRelic
       #
       # This happens after the agent has loaded and all dependencies
       # are ready to be instrumented
-      def add_instrumentation pattern
+      def add_instrumentation(pattern)
         if @instrumented
-          load_instrumentation_files pattern
+          load_instrumentation_files(pattern)
         else
           @instrumentation_files << pattern
         end
@@ -57,15 +56,44 @@ module NewRelic
 
         # Instrumentation for the key code points inside rails for monitoring by NewRelic.
         # note this file is loaded only if the newrelic agent is enabled (through config/newrelic.yml)
-        instrumentation_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'agent','instrumentation'))
+        instrumentation_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'agent', 'instrumentation'))
         @instrumentation_files <<
-        File.join(instrumentation_path, '*.rb') <<
-        File.join(instrumentation_path, app.to_s, '*.rb')
-        @instrumentation_files.each { | pattern |  load_instrumentation_files pattern }
+          File.join(instrumentation_path, '*.rb') <<
+          File.join(instrumentation_path, app.to_s, '*.rb')
+        @instrumentation_files.each { |pattern| load_instrumentation_files(pattern) }
         DependencyDetection.detect!
-        ::NewRelic::Agent.logger.info "Finished instrumentation"
+        ruby_deprecation
+        rails_32_deprecation
+        ::NewRelic::Agent.logger.info("Finished instrumentation")
       end
     end
+
+    def rails_32_deprecation
+      return unless defined?(Rails::VERSION) && Gem::Version.new(Rails::VERSION::STRING) <= Gem::Version.new('3.2')
+
+      deprecation_msg = 'The Ruby Agent is dropping support for Rails 3.2 ' \
+        'in a future major release. Please upgrade your Rails version to continue receiving support. ' \
+
+      Agent.logger.log_once(
+        :warn,
+        :deprecated_rails_version,
+        deprecation_msg
+      )
+    end
+
+    def ruby_deprecation
+      return unless RUBY_VERSION < '2.4.0'
+
+      deprecation_msg = 'The Ruby Agent is dropping support for Rubies below 2.4 ' \
+        'in version 9.0.0. Please upgrade your Ruby version to continue receiving support. ' \
+
+      ::NewRelic::Agent.logger.log_once(
+        :warn,
+        :deprecated_ruby_version,
+        deprecation_msg
+      )
+    end
+
     include Instrumentation
   end
 end

data/lib/new_relic/control/private_instance_methods.rb

@@ -0,0 +1,48 @@
+# 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/memory_logger'
+require 'new_relic/agent/agent_logger'
+
+module NewRelic
+  class Control
+    module PrivateInstanceMethods
+      private
+
+      def configure_high_security
+        if security_settings_valid? && Agent.config[:high_security]
+          Agent.logger.info("Installing high security configuration based on local configuration")
+          Agent.config.replace_or_add_config(Agent::Configuration::HighSecuritySource.new(Agent.config))
+        end
+      end
+
+      def log_yaml_source_failures(yaml_source)
+        yaml_source.failures.each { |msg| stdout.puts Agent::AgentLogger.format_fatal_error(msg) }
+      end
+
+      def config_file_path
+        @config_file_override || Agent.config[:config_path]
+      end
+
+      def create_logger(options)
+        if ::NewRelic::Agent.logger.is_startup_logger?
+          ::NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new(root, options.delete(:log))
+        end
+      end
+
+      def init_instrumentation
+        if !security_settings_valid?
+          handle_invalid_security_settings
+        elsif Agent.config[:agent_enabled] && !NewRelic::Agent.instance.started?
+          start_agent
+          install_instrumentation
+        elsif !Agent.config[:agent_enabled]
+          install_shim
+        else
+          DependencyDetection.detect!
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/control/server_methods.rb

@@ -1,12 +1,11 @@
-# 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
   class Control
-
     # Structs holding info for the remote server and proxy server
-    class Server < Struct.new :name, :port #:nodoc:
+    class Server < Struct.new(:name, :port) # :nodoc:
       def to_s; "#{name}:#{port}"; end
     end
 
@@ -22,7 +21,7 @@ module NewRelic
         @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port])
       end
 
-      def server_from_host(hostname=nil)
+      def server_from_host(hostname = nil)
         NewRelic::Control::Server.new(hostname || Agent.config[:host], Agent.config[:port])
       end
     end

data/lib/new_relic/control.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 'yaml'
 require 'new_relic/dependency_detection'
@@ -23,7 +23,6 @@ require 'new_relic/agent'
 require 'new_relic/delayed_job_injection'
 
 module NewRelic
-
   # The Control is a singleton responsible for the startup and
   # initialization sequence.  The initializer uses a LocalEnvironment to
   # detect the framework and instantiates the framework specific

data/lib/new_relic/delayed_job_injection.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 DelayedJobInjection

data/lib/new_relic/dependency_detection.rb

@@ -1,9 +1,8 @@
-# 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 DependencyDetection
-
   module_function
 
   @items = []
@@ -21,6 +20,7 @@ module DependencyDetection
     end
 
     @items << item
+    return item
   end
 
   def detect!
@@ -32,7 +32,7 @@ module DependencyDetection
   end
 
   def dependency_by_name(name)
-    @items.find {|i| i.name == name }
+    @items.find { |i| i.name == name }
   end
 
   def installed?(name)
@@ -51,32 +51,73 @@ module DependencyDetection
   class Dependent
     attr_reader :executed
     attr_accessor :name
+    attr_writer :config_name
+    attr_reader :dependencies
+    attr_reader :prepend_conflicts
+
     def executed!
       @executed = true
     end
 
-    attr_reader :dependencies
+    def config_name
+      @config_name || @name
+    end
 
     def initialize
       @dependencies = []
       @executes = []
+      @prepend_conflicts = []
       @name = nil
+      @config_name = nil
     end
 
     def dependencies_satisfied?
       !executed and check_dependencies
     end
 
-    def source_location_for klass, method_name
+    def source_location_for(klass, method_name)
       Object.instance_method(:method).bind(klass.allocate).call(method_name).source_location.to_s
     end
-  
+
+    # Extracts the instrumented library name from the instrumenting module's name
+    # Given "NewRelic::Agent::Instrumentation::NetHTTP::Prepend"
+    # Will extract "NetHTTP" which is in the 2nd to last spot
+    def extract_supportability_name(instrumenting_module)
+      instrumenting_module.to_s.split("::")[-2]
+    end
+
+    def log_and_instrument(method, instrumenting_module, supportability_name)
+      supportability_name ||= extract_supportability_name(instrumenting_module)
+      NewRelic::Agent.logger.info("Installing New Relic supported #{supportability_name} instrumentation using #{method}")
+      NewRelic::Agent.record_metric("Supportability/Instrumentation/#{supportability_name}/#{method}", 0.0)
+      yield
+    end
+
+    def prepend_instrument(target_class, instrumenting_module, supportability_name = nil)
+      log_and_instrument("Prepend", instrumenting_module, supportability_name) do
+        target_class.send(:prepend, instrumenting_module)
+      end
+    end
+
+    def chain_instrument(instrumenting_module, supportability_name = nil)
+      log_and_instrument("MethodChaining", instrumenting_module, supportability_name) do
+        instrumenting_module.instrument!
+      end
+    end
+
+    def chain_instrument_target(target, instrumenting_module, supportability_name = nil)
+      NewRelic::Agent.logger.info("Installing deferred #{target} instrumentation")
+      log_and_instrument("MethodChaining", instrumenting_module, supportability_name) do
+        instrumenting_module.instrument!(target)
+      end
+    end
+
     def execute
       @executes.each do |x|
         begin
           x.call
         rescue => err
-          NewRelic::Agent.logger.error( "Error while installing #{self.name} instrumentation:", err )
+          NewRelic::Agent.logger.error("Error while installing #{self.name} instrumentation:", err)
           break
         end
       end
@@ -91,35 +132,101 @@ module DependencyDetection
         begin
           dep.call
         rescue => err
-          NewRelic::Agent.logger.error( "Error while detecting #{self.name}:", err )
+          NewRelic::Agent.logger.error("Error while detecting #{self.name}:", err)
           false
         end
       end
     end
 
-    def depends_on &block
-      @dependencies << block if block_given?
+    def depends_on(&block)
+      @dependencies << block if block
     end
 
     def allowed_by_config?
-      # If we don't have a name, can't check config so allow it
-      return true if self.name.nil?
+      !(disabled_configured? || deprecated_disabled_configured?)
+    end
+
+    # TODO: MAJOR VERSION
+    # will only return true if a disabled key is found and is truthy
+    def deprecated_disabled_configured?
+      return false if self.name.nil?
 
       key = "disable_#{self.name}".to_sym
-      if (::NewRelic::Agent.config[key] == true)
-        ::NewRelic::Agent.logger.debug("Not installing #{self.name} instrumentation because of configuration #{key}")
-        false
-      else
-        true
+      return false unless ::NewRelic::Agent.config[key] == true
+
+      ::NewRelic::Agent.logger.debug("Not installing #{self.name} instrumentation because of configuration #{key}")
+      ::NewRelic::Agent.logger.debug( \
+        "[DEPRECATED] configuration #{key} for #{self.name} will be removed in the next major release. " \
+        "Use `#{config_key}` with one of `#{VALID_CONFIG_VALUES.map(&:to_s).inspect}`"
+      )
+
+      return true
+    end
+
+    def config_key
+      return nil if self.config_name.nil?
+
+      @config_key ||= "instrumentation.#{self.config_name}".to_sym
+    end
+
+    VALID_CONFIG_VALUES = [:auto, :disabled, :prepend, :chain]
+    AUTO_CONFIG_VALUE = VALID_CONFIG_VALUES[0]
+
+    VALID_CONFIG_VALUES.each do |value|
+      define_method "#{value}_configured?" do
+        value == config_value
       end
     end
 
+    # returns only a valid value for instrumentation configuration
+    # If user uses "enabled" it's converted to "auto"
+    def valid_config_value(retrieved_value)
+      VALID_CONFIG_VALUES.include?(retrieved_value) ? retrieved_value : AUTO_CONFIG_VALUE
+    end
+
+    # fetches and transform potentially invalid value given to one of the valid config values
+    # logs the resolved value during debug mode.
+    def fetch_config_value(key)
+      valid_value = valid_config_value(::NewRelic::Agent.config[key].to_s.to_sym)
+      ::NewRelic::Agent.logger.debug("Using #{valid_value} configuration value for #{self.name} to configure instrumentation")
+      return valid_value
+    end
+
+    def config_value
+      return AUTO_CONFIG_VALUE unless config_key
+
+      fetch_config_value(config_key)
+    end
+
     def named(new_name)
       self.name = new_name
     end
 
-    def executes &block
-      @executes << block if block_given?
+    def configure_with(new_config_name)
+      self.config_name = new_config_name
+    end
+
+    def executes(&block)
+      @executes << block if block
+    end
+
+    def conflicts_with_prepend(&block)
+      @prepend_conflicts << block if block
+    end
+
+    def use_prepend?
+      prepend_configured? || (auto_configured? && !prepend_conflicts?)
+    end
+
+    def prepend_conflicts?
+      @prepend_conflicts.any? do |conflict|
+        begin
+          conflict.call
+        rescue => err
+          NewRelic::Agent.logger.error("Error while checking prepend conflicts #{self.name}:", err)
+          false # assumes no conflicts exist since `prepend` is preferred method of instrumenting
+        end
+      end
     end
   end
 end

data/lib/new_relic/environment_report.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
   # The EnvironmentReport is responsible for analyzing the application's
@@ -13,7 +13,6 @@ module NewRelic
   # Additional logic can be registered by using the EnvironmentReport.report_on
   # hook.
   class EnvironmentReport
-
     # This is the main interface for registering logic that should be included
     # in the Environment Report. For example:
     #
@@ -57,23 +56,23 @@ module NewRelic
         end
       end
     end
-    report_on('Plugin List'       ) { ::Rails.configuration.plugins.to_a }
-    report_on('Ruby version'      ) { RUBY_VERSION                       }
-    report_on('Ruby description'  ) { RUBY_DESCRIPTION                   }
-    report_on('Ruby platform'     ) { RUBY_PLATFORM                      }
-    report_on('Ruby patchlevel'   ) { RUBY_PATCHLEVEL.to_s               }
-    report_on('JRuby version'     ) { JRUBY_VERSION                      }
-    report_on('Java VM version'   ) { ENV_JAVA['java.vm.version']        }
+    report_on('Plugin List') { ::Rails.configuration.plugins.to_a }
+    report_on('Ruby version') { RUBY_VERSION }
+    report_on('Ruby description') { RUBY_DESCRIPTION }
+    report_on('Ruby platform') { RUBY_PLATFORM }
+    report_on('Ruby patchlevel') { RUBY_PATCHLEVEL.to_s }
+    report_on('JRuby version') { JRUBY_VERSION }
+    report_on('Java VM version') { ENV_JAVA['java.vm.version'] }
     report_on('Logical Processors') { ::NewRelic::Agent::SystemInfo.num_logical_processors }
-    report_on('Physical Cores'    ) { ::NewRelic::Agent::SystemInfo.num_physical_cores     }
-    report_on('Arch'              ) { ::NewRelic::Agent::SystemInfo.processor_arch         }
-    report_on('OS version'        ) { ::NewRelic::Agent::SystemInfo.os_version             }
-    report_on('OS'                ) { ::NewRelic::Agent::SystemInfo.ruby_os_identifier     }
-    report_on('Database adapter'  ) { ::NewRelic::Agent::DatabaseAdapter.value }
-    report_on('Framework'       ) { Agent.config[:framework].to_s  }
-    report_on('Dispatcher'      ) { Agent.config[:dispatcher].to_s }
-    report_on('Environment'     ) { NewRelic::Control.instance.env }
-    report_on('Rails version'   ) { ::Rails::VERSION::STRING       }
+    report_on('Physical Cores') { ::NewRelic::Agent::SystemInfo.num_physical_cores }
+    report_on('Arch') { ::NewRelic::Agent::SystemInfo.processor_arch }
+    report_on('OS version') { ::NewRelic::Agent::SystemInfo.os_version }
+    report_on('OS') { ::NewRelic::Agent::SystemInfo.ruby_os_identifier }
+    report_on('Database adapter') { ::NewRelic::Agent::DatabaseAdapter.value }
+    report_on('Framework') { Agent.config[:framework].to_s }
+    report_on('Dispatcher') { Agent.config[:dispatcher].to_s }
+    report_on('Environment') { NewRelic::Control.instance.env }
+    report_on('Rails version') { ::Rails::VERSION::STRING }
     report_on('Rails threadsafe') do
       ::Rails.configuration.action_controller.allow_concurrency
     end
@@ -88,27 +87,15 @@ module NewRelic
     # end reporting logic
     ####################################
 
-
     attr_reader :data
     # Generate the report based on the class level logic.
     def initialize
       @data = self.class.registered_reporters.inject(Hash.new) do |data, (key, logic)|
         begin
           value = logic.call
-          if value
-            data[key] = value
-
-            Agent.record_metric("Supportability/EnvironmentReport/success", 0.0)
-            Agent.record_metric("Supportability/EnvironmentReport/success/#{key}", 0.0)
-          else
-            Agent.logger.debug("EnvironmentReport ignoring value for #{key.inspect} which came back falsey: #{value.inspect}")
-            Agent.record_metric("Supportability/EnvironmentReport/empty", 0.0)
-            Agent.record_metric("Supportability/EnvironmentReport/empty/#{key}", 0.0)
-          end
+          value ? record_value(data, key, value) : record_empty_value(key, value)
         rescue => e
-          Agent.logger.debug("EnvironmentReport failed to retrieve value for #{key.inspect}: #{e}")
-          Agent.record_metric("Supportability/EnvironmentReport/error", 0.0)
-          Agent.record_metric("Supportability/EnvironmentReport/error/#{key}", 0.0)
+          rescue_initialize(key, e)
         end
         data
       end
@@ -125,5 +112,26 @@ module NewRelic
     def to_a
       @data.to_a
     end
+
+    private
+
+    def record_value(data, key, value)
+      data[key] = value
+
+      Agent.record_metric("Supportability/EnvironmentReport/success", 0.0)
+      Agent.record_metric("Supportability/EnvironmentReport/success/#{key}", 0.0)
+    end
+
+    def record_empty_value(key, value)
+      Agent.logger.debug("EnvironmentReport ignoring value for #{key.inspect} which came back falsey: #{value.inspect}")
+      Agent.record_metric("Supportability/EnvironmentReport/empty", 0.0)
+      Agent.record_metric("Supportability/EnvironmentReport/empty/#{key}", 0.0)
+    end
+
+    def rescue_initialize(key, exception)
+      Agent.logger.debug("EnvironmentReport failed to retrieve value for #{key.inspect}: #{exception}")
+      Agent.record_metric("Supportability/EnvironmentReport/error", 0.0)
+      Agent.record_metric("Supportability/EnvironmentReport/error/#{key}", 0.0)
+    end
   end
 end