newrelic_rpm 5.7.0.350 → 9.0.0

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/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 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,28 +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)
+      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
@@ -87,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
-      @dependencies << Proc.new
+    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
-      @executes << Proc.new
+    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/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
   # 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,25 +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'  ) do
-      ActiveRecord::Base.configurations[NewRelic::Control.instance.env]['adapter']
-    end
-    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
@@ -90,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
@@ -127,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

data/lib/new_relic/helper.rb

@@ -1,10 +1,14 @@
-# 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 'open3'
 
 module NewRelic
+  class CommandExecutableNotFoundError < StandardError; end
+  class CommandRunFailedError < StandardError; end
+
   # A singleton for shared generic helper methods
   module Helper
     extend self
@@ -12,16 +16,17 @@ module NewRelic
     # Confirm a string is correctly encoded,
     # If not force the encoding to ASCII-8BIT (binary)
     def correctly_encoded(string)
-      return string unless string.is_a? String
+      return string unless string.is_a?(String)
+
       # The .dup here is intentional, since force_encoding mutates the target,
       # and we don't know who is going to use this string downstream of us.
       string.valid_encoding? ? string : string.dup.force_encoding(Encoding::ASCII_8BIT)
     end
 
     def instance_method_visibility(klass, method_name)
-      if klass.private_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+      if klass.private_instance_methods.map { |s| s.to_sym }.include?(method_name.to_sym)
         :private
-      elsif klass.protected_instance_methods.map{|s|s.to_sym}.include? method_name.to_sym
+      elsif klass.protected_instance_methods.map { |s| s.to_sym }.include?(method_name.to_sym)
         :protected
       else
         :public
@@ -31,14 +36,50 @@ module NewRelic
     def instance_methods_include?(klass, method_name)
       method_name_sym = method_name.to_sym
       (
-        klass.instance_methods.map{ |s| s.to_sym }.include?(method_name_sym)          ||
-        klass.protected_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym) ||
-        klass.private_instance_methods.map{ |s|s.to_sym }.include?(method_name_sym)
+        klass.instance_methods.map { |s| s.to_sym }.include?(method_name_sym) ||
+        klass.protected_instance_methods.map { |s| s.to_sym }.include?(method_name_sym) ||
+        klass.private_instance_methods.map { |s| s.to_sym }.include?(method_name_sym)
       )
     end
 
     def time_to_millis(time)
       (time.to_f * 1000).round
     end
+
+    def run_command(command)
+      executable = command.split(' ').first
+      unless executable_in_path?(executable)
+        raise NewRelic::CommandExecutableNotFoundError.new("Executable not found: '#{executable}'")
+      end
+
+      exception = nil
+      begin
+        output, status = Open3.capture2e(command)
+      rescue => exception
+      end
+
+      if exception || !status.success?
+        message = exception ? "#{exception.class} - #{exception.message}" : output
+        raise NewRelic::CommandRunFailedError.new("Failed to run command '#{command}': #{message}")
+      end
+
+      output.chomp if output
+    end
+
+    # TODO: Open3 defers the actual execution of a binary to Process.spawn,
+    #       which will raise an Errno::ENOENT exception for a file that
+    #       cannot be found. We might want to take the time to evaluate
+    #       relying on that Process.spawn behavior instead of checking for
+    #       existence ourselves. We'd need to see what it does, how efficient
+    #       it is, if it differs in functionality between Ruby versions and
+    #       operating systems, etc.
+    def executable_in_path?(executable)
+      return false unless ENV['PATH']
+
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |bin_path|
+        executable_path = File.join(bin_path, executable)
+        File.exist?(executable_path) && File.file?(executable_path) && File.executable?(executable_path)
+      end
+    end
   end
 end

data/lib/new_relic/language_support.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
 
 module NewRelic
   module LanguageSupport
@@ -9,7 +9,8 @@ module NewRelic
     @@forkable = nil
     def can_fork?
       # this is expensive to check, so we should only check once
-      return @@forkable if @@forkable != nil
+      return @@forkable if !@@forkable.nil?
+
       @@forkable = Process.respond_to?(:fork)
     end
 
@@ -22,7 +23,8 @@ module NewRelic
     end
 
     def object_space_usable?
-      if defined?(::JRuby) && JRuby.respond_to?(:runtime)
+      if jruby?
+        require 'jruby'
         JRuby.runtime.is_object_space_enabled
       else
         defined?(::ObjectSpace)
@@ -33,12 +35,29 @@ module NewRelic
       RUBY_ENGINE == 'jruby'
     end
 
+    # TODO: OLD RUBIES - RUBY_VERSION < 2.6
+    #
+    # Ruby 2.6 introduced an improved version of `Object.const_get` that
+    # respects the full namespace of the input and doesn't just grab the first
+    # constant matching the string to the right of the last '::'.
+    # Once we drop support for Ruby 2.5 and below, the only value this custom
+    # method will provide beyond `Object.const_get` itself is to automatically
+    # catch NameError.
+    #
+    # see: https://github.com/rails/rails/commit/7057ccf6565c1cb5354c1906880119276a9d15c0
+    #
+    # With Ruby 2.6+, this method can be defined like so:
+    # def constantize(constant_as_string_or_symbol)
+    #   Object.const_get(constant_as_string_or_symbol)
+    # rescue NameError
+    # end
+    #
     def constantize(const_name)
-      const_name.to_s.sub(/\A::/,'').split('::').inject(Object) do |namespace, name|
+      const_name.to_s.sub(/\A::/, '').split('::').inject(Object) do |namespace, name|
         begin
           result = namespace.const_get(name)
 
-          # const_get looks up the inheritence chain, so if it's a class
+          # const_get looks up the inheritance chain, so if it's a class
           # in the constant make sure we found the one in our namespace.
           #
           # Can't help if the constant isn't a class...
@@ -54,6 +73,11 @@ module NewRelic
       end
     end
 
+    def camelize(string)
+      camelized = string.downcase
+      camelized.split(/\-|\_/).map(&:capitalize).join
+    end
+
     def bundled_gem?(gem_name)
       defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?(gem_name)
     rescue => e

data/lib/new_relic/latest_changes.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
 
 module NewRelic
   module LatestChanges
@@ -9,11 +9,11 @@ module NewRelic
     end
 
     FOOTER = <<'EOS'
-    See https://github.com/newrelic/rpm/blob/master/CHANGELOG.md for a full list of
+    See https://github.com/newrelic/newrelic-ruby-agent/blob/main/CHANGELOG.md for a full list of
     changes.
 EOS
 
-    def self.read(changelog=default_changelog)
+    def self.read(changelog = default_changelog)
       changes = extract_latest_changes(File.read(changelog))
       changes << FOOTER
 
@@ -24,14 +24,14 @@ EOS
     # precise version number included in the line in parens. For example:
     #
     # * This is a patch item (3.7.1.188)
-    def self.read_patch(patch_level, changelog=default_changelog)
+    def self.read_patch(patch_level, changelog = default_changelog)
       latest = extract_latest_changes(File.read(changelog))
       changes = ["## v#{patch_level}", ""]
 
       current_item = nil
       latest.each do |line|
-        if line.match(/^\s*\*.*/)
-          if line.match(/\(#{patch_level}\)/)
+        if line =~ /^\s*\*.*/
+          if line =~ /\(#{patch_level}\)/
             # Found a patch level item, so start tracking the lines!
             current_item = line
           else
@@ -52,10 +52,11 @@ EOS
       changes = []
       version_count = 0
       contents.each_line do |line|
-        if line.match(/##\s+v[\d.]+/)
+        if line =~ /##\s+v[\d.]+/
           version_count += 1
         end
         break if version_count >= 2
+
         changes << line.sub(/^  \* /, "* ").chomp
       end
       changes