newrelic_rpm 3.12.0.288 → 9.10.2

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/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/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,31 +64,30 @@ 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
+        # Rails applications load the next two lines before any other initializers are run
+        unless defined?(Rails::VERSION) && ENV['NEW_RELIC_DEFER_RAILS_INITIALIZATION']
+          Module.send(:include, NewRelic::Agent::MethodTracer::ClassMethods)
+          Module.send(:include, NewRelic::Agent::MethodTracer)
+        end
+
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
-        NewRelic::Agent.agent.start_service_if_needed
-        if 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)
+        options[:env] = :serverless if local_env.discovered_dispatcher == :serverless
         env = options[:env] || self.env
         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 in #{env.inspect} environment.",
-                            "To prevent agent startup add a NEWRELIC_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
@@ -98,13 +97,26 @@ module NewRelic
         manual = Agent::Configuration::ManualSource.new(options)
         Agent.config.replace_or_add_config(manual)
 
-        config_file_path = @config_file_override || Agent.config[:config_path]
-        Agent.config.replace_or_add_config(Agent::Configuration::YamlSource.new(config_file_path, env))
+        # if manual config sees serverless mode enabled, then the proc
+        # must have returned 'true'. don't bother with YAML and high security
+        # in a serverless context
+        return if Agent.config[:'serverless_mode.enabled']
 
-        if 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
+        yaml_source = Agent::Configuration::YamlSource.new(config_file_path, env)
+        log_yaml_source_failures(yaml_source) if yaml_source.failed?
+        Agent.config.replace_or_add_config(yaml_source)
+        configure_high_security
+      end
+
+      def security_settings_valid?
+        !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).')
+        install_shim
       end
 
       # Install the real agent into the Agent module, and issue the start command.
@@ -142,8 +154,11 @@ 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
@@ -152,6 +167,9 @@ module NewRelic
         '.'
       end
 
+      def stdout
+        STDOUT
+      end
     end
     include InstanceMethods
   end

data/lib/new_relic/control/instrumentation.rb

@@ -1,38 +1,29 @@
-# 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
   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
 
-      # Install stubs to the proper location so the app code will not fail
-      # if the agent is not running.
       def install_shim
-        # Once we install instrumentation, you can't undo that by installing the shim.
-        if @instrumented
-          NewRelic::Agent.logger.error "Cannot install the Agent shim after instrumentation has already been installed!"
-          NewRelic::Agent.logger.error caller.join("\n")
-        else
-          NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
-        end
+        # implemented only in subclasses
       end
 
       # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.
@@ -42,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
@@ -65,15 +56,30 @@ 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"
+        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
+
     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,20 +1,16 @@
-# 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
   class Control
-
     # Structs holding info for the remote server and proxy server
-    class Server < Struct.new :name, :port, :ip #:nodoc:
+    class Server < Struct.new(:name, :port) # :nodoc:
       def to_s; "#{name}:#{port}"; end
     end
 
-    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
-
     # Contains methods that deal with connecting to the server
     module ServerMethods
-
       def server
         @remote_server ||= server_from_host(nil)
       end
@@ -22,61 +18,11 @@ module NewRelic
       # the server we should contact for api requests, like uploading
       # deployments and the like
       def api_server
-        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port], nil)
-      end
-
-      # a new instances of the proxy server - this passes through if
-      # there is no proxy, otherwise it has proxy configuration
-      # information pulled from the config file
-      def proxy_server
-        @proxy_server ||= NewRelic::Control::ProxyServer.new(Agent.config[:proxy_host],
-                                                             Agent.config[:proxy_port],
-                                                             Agent.config[:proxy_user],
-                                                             Agent.config[:proxy_pass])
-      end
-
-      # turns a hostname into an ip address and returns a
-      # NewRelic::Control::Server that contains the configuration info
-      def server_from_host(hostname=nil)
-        host = hostname || Agent.config[:host]
-
-        # if the host is not an IP address, turn it into one
-        NewRelic::Control::Server.new(host, Agent.config[:port],
-                                      convert_to_ip_address(host))
-      end
-
-      # Check to see if we need to look up the IP address
-      # If it's an IP address already, we pass it through.
-      # If it's nil, or localhost, we don't bother.
-      # Otherwise, use `resolve_ip_address` to find one
-      def convert_to_ip_address(host)
-        # here we leave it as a host name since the cert verification
-        # needs it in host form
-        return host if Agent.config[:ssl]
-        # We won't talk directly to the host, so no need to resolve if proxy configured
-        return host if Agent.config[:proxy_host]
-        return nil if host.nil? || host.downcase == "localhost"
-        ip = resolve_ip_address(host)
-
-        ::NewRelic::Agent.logger.debug "Resolved #{host} to #{ip}"
-        ip
+        @api_server ||= NewRelic::Control::Server.new(Agent.config[:api_host], Agent.config[:api_port])
       end
 
-      # Look up the ip address of the host using the pure ruby lookup
-      # to prevent blocking.  If that fails, fall back to the regular
-      # IPSocket library.  Return nil if we can't find the host ip
-      # address and don't have a good default.
-      def resolve_ip_address(host)
-        Resolv.getaddress(host)
-      rescue => e
-        ::NewRelic::Agent.logger.warn("DNS Error caching IP address:", e)
-        begin
-          ::NewRelic::Agent.logger.debug("Trying native DNS lookup since Resolv failed")
-          IPSocket.getaddress(host)
-        rescue => e
-          ::NewRelic::Agent.logger.error("Could not look up server address: #{e}")
-          nil
-        end
+      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,13 +1,12 @@
-# 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 'yaml'
-require 'conditional_vendored_dependency_detection'
+require 'new_relic/dependency_detection'
 require 'new_relic/local_environment'
 require 'new_relic/language_support'
 require 'new_relic/helper'
-require 'new_relic/json_wrapper'
 
 require 'singleton'
 require 'erb'
@@ -24,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/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 DelayedJobInjection

data/lib/new_relic/dependency_detection.rb

@@ -0,0 +1,234 @@
+# 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 = []
+
+  def defer(&block)
+    item = Dependent.new
+    item.instance_eval(&block)
+
+    if item.name
+      seen_names = @items.map { |i| i.name }.compact
+      if seen_names.include?(item.name)
+        NewRelic::Agent.logger.warn("Refusing to re-register DependencyDetection block with name '#{item.name}'")
+        return @items
+      end
+    end
+
+    @items << item
+    return item
+  end
+
+  def detect!
+    @items.each do |item|
+      if item.dependencies_satisfied?
+        item.execute
+      else
+        item.configure_as_unsatisfied unless item.disabled_configured?
+      end
+    end
+  end
+
+  def dependency_by_name(name)
+    @items.find { |i| i.name == name }
+  end
+
+  class Dependent
+    attr_reader :executed
+    attr_accessor :name
+    attr_writer :config_name
+    attr_reader :dependencies
+    attr_reader :prepend_conflicts
+
+    def executed!
+      @executed = true
+    end
+
+    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 configure_as_unsatisfied
+      NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = :unsatisfied
+    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)
+          break
+        end
+      end
+    ensure
+      executed!
+    end
+
+    def check_dependencies
+      return false unless allowed_by_config? && dependencies
+
+      dependencies.all? do |dep|
+        begin
+          dep.call
+        rescue => err
+          NewRelic::Agent.logger.error("Error while detecting #{self.name}:", err)
+          false
+        end
+      end
+    end
+
+    def depends_on(&block)
+      @dependencies << block if block
+    end
+
+    def allowed_by_config?
+      !(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
+      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
+
+    # update any :auto config value to be either :prepend or :chain after auto
+    # determination has selected one of those to use
+    def update_config_value(use_prepend)
+      if config_key && auto_configured?
+        NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = use_prepend ? :prepend : :chain
+      end
+      use_prepend
+    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 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?
+      update_config_value(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