newrelic_rpm 6.15.0 → 9.7.1

data/lib/new_relic/constants.rb

@@ -1,23 +1,24 @@
-# 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
+  ASTERISK = '*'
+
   PRIORITY_PRECISION = 6
 
   EMPTY_ARRAY = [].freeze
   EMPTY_HASH = {}.freeze
-  EMPTY_STR = ""
+  EMPTY_STR = ''
 
-  HTTP = "HTTP"
-  HTTPS = "HTTPS"
-  UNKNOWN = "Unknown"
+  HTTP = 'HTTP'
+  HTTPS = 'HTTPS'
+  UNKNOWN = 'Unknown'
 
   FORMAT_NON_RACK = 0
   FORMAT_RACK = 1
 
-  NEWRELIC_KEY = "newrelic"
+  NEWRELIC_KEY = 'newrelic'
   CANDIDATE_NEWRELIC_KEYS = [
     NEWRELIC_KEY,
     'NEWRELIC',
@@ -25,18 +26,18 @@ module NewRelic
     'Newrelic'
   ].freeze
 
-  TRACEPARENT_KEY = "traceparent"
-  TRACESTATE_KEY = "tracestate"
+  TRACEPARENT_KEY = 'traceparent'
+  TRACESTATE_KEY = 'tracestate'
 
-  # Right now, old and new Rubies are the same.  Intention is to use "(...)" for
-  # Ruby 2.7+ for argument delegation, but doing so is a breaking API change.
-  ARGS_FOR_RUBY_VERSION = RUBY_VERSION < "2.7.0" ? "*args, &block" : "*args, &block"
+  STANDARD_OUT = 'STDOUT'
 
   HTTP_TRACEPARENT_KEY = "HTTP_#{TRACEPARENT_KEY.upcase}"
   HTTP_TRACESTATE_KEY = "HTTP_#{TRACESTATE_KEY.upcase}"
   HTTP_NEWRELIC_KEY = "HTTP_#{NEWRELIC_KEY.upcase}"
 
   CONNECT_RETRY_PERIODS = [15, 15, 30, 60, 120, 300]
-  MIN_RETRY_PERIOD = 15
   MAX_RETRY_PERIOD = 300
+
+  SLASH = '/'
+  ROOT = SLASH
 end

data/lib/new_relic/control/class_methods.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
   class Control
@@ -9,7 +9,7 @@ module NewRelic
     module ClassMethods
       # Access the Control singleton, lazy initialized.  Default will instantiate a new
       # instance or pass false to defer
-      def instance(create=true)
+      def instance(create = true)
         @instance ||= create && new_instance
       end
 
@@ -35,8 +35,8 @@ module NewRelic
 
       # nb this does not 'load test' the framework, it loads the 'test framework'
       def load_test_framework
-        config = File.expand_path(File.join('..','..','..','..', "test","config","newrelic.yml"), __FILE__)
-        require "config/test_control"
+        config = File.expand_path(File.join('..', '..', '..', '..', 'test', 'config', 'newrelic.yml'), __FILE__)
+        require 'config/test_control'
         NewRelic::Control::Frameworks::Test.new(local_env, config)
       end
 
@@ -49,18 +49,12 @@ module NewRelic
           # maybe it is already loaded by some external system
           # i.e. rpm_contrib or user extensions?
         end
-        NewRelic::Control::Frameworks.const_get(camelize(framework.to_s))
+        NewRelic::Control::Frameworks.const_get(NewRelic::LanguageSupport.camelize(framework.to_s))
       end
 
       # The root directory for the plugin or gem
       def newrelic_root
-        File.expand_path(File.join("..", "..", "..", ".."), __FILE__)
-      end
-
-      def camelize(snake_case_name)
-        snake_case_name.gsub(/(\_|^)[a-z]/) do |substring|
-          substring[-1].capitalize!
-        end
+        File.expand_path(File.join('..', '..', '..', '..'), __FILE__)
       end
     end
     extend ClassMethods

data/lib/new_relic/control/frameworks/external.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 'new_relic/control/frameworks/ruby'
 module NewRelic
@@ -11,7 +11,7 @@ module NewRelic
       # out specifically because in this context we are not monitoring
       # the running process, but actually external things.
       class External < NewRelic::Control::Frameworks::Ruby
-        def init_config(options={})
+        def init_config(options = {})
           super
         end
       end

data/lib/new_relic/control/frameworks/rails.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 'new_relic/control/frameworks/ruby'
 module NewRelic
@@ -10,9 +10,11 @@ module NewRelic
       # Rails specific configuration, instrumentation, environment values,
       # etc.
       class Rails < NewRelic::Control::Frameworks::Ruby
+        BROWSER_MONITORING_INSTALLED_SINGLETON = NewRelic::Agent.config
+        BROWSER_MONITORING_INSTALLED_VARIABLE = :@browser_monitoring_installed
 
         def env
-          @env ||= ( ENV['NEW_RELIC_ENV'] || RAILS_ENV.dup )
+          @env ||= (ENV['NEW_RELIC_ENV'] || RAILS_ENV.dup)
         end
 
         # Rails can return an empty string from this method, causing
@@ -43,57 +45,85 @@ module NewRelic
         # In versions of Rails prior to 2.0, the rails config was only available to
         # the init.rb, so it had to be passed on from there.  This is a best effort to
         # find a config and use that.
-        def init_config(options={})
+        def init_config(options = {})
           @config = options[:config]
-          # Install the dependency detection,
-          if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
-            rails_config.after_initialize do
-              # This will insure we load all the instrumentation as late as possible.  If the agent
-              # is not enabled, it will load a limited amount of instrumentation.
-              DependencyDetection.detect!
-            end
+          install_dependency_detection
+          install_browser_monitoring_and_agent_hooks
+        rescue => e
+          ::NewRelic::Agent.logger.error('Failure during init_config for Rails. Is Rails required in a non-Rails ' \
+                                         'app? Set NEW_RELIC_FRAMEWORK=ruby to avoid this message. The Ruby agent ' \
+                                         'will continue running, but Rails-specific features may be missing. ' \
+                                         "#{e.class} - #{e.message}")
+        end
+
+        def install_dependency_detection
+          return unless rails_config && ::Rails.configuration.respond_to?(:after_initialize)
+
+          rails_config.after_initialize do
+            # This will insure we load all the instrumentation as late as
+            # possible. If the agent is not enabled, it will load a limited
+            # amount of instrumentation.
+            DependencyDetection.detect!
           end
+        end
+
+        def install_browser_monitoring_and_agent_hooks
+          return unless rails_config
+
           if !Agent.config[:agent_enabled]
-            # Might not be running if it does not think mongrel, thin, passenger, etc
-            # is running, if it thinks it's a rake task, or if the agent_enabled is false.
-            ::NewRelic::Agent.logger.info("New Relic Agent not running.")
+            # Might not be running if it does not think mongrel, thin,
+            # passenger, etc. is running, if it thinks it's a rake task, or
+            # if the agent_enabled is false.
+            ::NewRelic::Agent.logger.info('New Relic agent not running. Skipping browser monitoring and agent hooks.')
           else
             install_browser_monitoring(rails_config)
             install_agent_hooks(rails_config)
           end
-        rescue => e
-          ::NewRelic::Agent.logger.error("Failure during init_config for Rails. Is Rails required in a non-Rails app? Set NEW_RELIC_FRAMEWORK=ruby to avoid this message.",
-                                         "The Ruby agent will continue running, but Rails-specific features may be missing.",
-                                         e)
         end
 
         def install_agent_hooks(config)
           return if defined?(@agent_hooks_installed) && @agent_hooks_installed
+
           @agent_hooks_installed = true
           return if config.nil? || !config.respond_to?(:middleware)
+
           begin
             require 'new_relic/rack/agent_hooks'
             return unless NewRelic::Rack::AgentHooks.needed?
-            config.middleware.use NewRelic::Rack::AgentHooks
-            ::NewRelic::Agent.logger.debug("Installed New Relic Agent Hooks middleware")
+
+            config.middleware.use(NewRelic::Rack::AgentHooks)
+            ::NewRelic::Agent.logger.debug('Installed New Relic agent hooks middleware')
           rescue => e
-            ::NewRelic::Agent.logger.warn("Error installing New Relic Agent Hooks middleware", e)
+            ::NewRelic::Agent.logger.warn('Error installing New Relic agent hooks middleware', e)
           end
         end
 
         def install_browser_monitoring(config)
-          return if defined?(@browser_monitoring_installed) && @browser_monitoring_installed
-          @browser_monitoring_installed = true
-          return if config.nil? || !config.respond_to?(:middleware) || !Agent.config[:'browser_monitoring.auto_instrument']
-          begin
-            require 'new_relic/rack/browser_monitoring'
-            config.middleware.use NewRelic::Rack::BrowserMonitoring
-            ::NewRelic::Agent.logger.debug("Installed New Relic Browser Monitoring middleware")
-          rescue => e
-            ::NewRelic::Agent.logger.warn("Error installing New Relic Browser Monitoring middleware", e)
+          @install_lock.synchronize do
+            return if browser_agent_already_installed?
+
+            mark_browser_agent_as_installed
+            return if config.nil? || !config.respond_to?(:middleware) || !Agent.config[:'browser_monitoring.auto_instrument']
+
+            begin
+              require 'new_relic/rack/browser_monitoring'
+              config.middleware.use(NewRelic::Rack::BrowserMonitoring)
+              ::NewRelic::Agent.logger.debug('Installed New Relic Browser Monitoring middleware')
+            rescue => e
+              ::NewRelic::Agent.logger.warn('Error installing New Relic Browser Monitoring middleware', e)
+            end
           end
         end
 
+        def browser_agent_already_installed?
+          BROWSER_MONITORING_INSTALLED_SINGLETON.instance_variable_defined?(BROWSER_MONITORING_INSTALLED_VARIABLE) &&
+            BROWSER_MONITORING_INSTALLED_SINGLETON.instance_variable_get(BROWSER_MONITORING_INSTALLED_VARIABLE)
+        end
+
+        def mark_browser_agent_as_installed
+          BROWSER_MONITORING_INSTALLED_SINGLETON.instance_variable_set(BROWSER_MONITORING_INSTALLED_VARIABLE, true)
+        end
+
         def rails_version
           @rails_version ||= Gem::Version.new(::Rails::VERSION::STRING)
         end
@@ -101,7 +131,7 @@ module NewRelic
         protected
 
         def rails_vendor_root
-          File.join(root,'vendor','rails')
+          File.join(root, 'vendor', 'rails')
         end
 
         def install_shim

data/lib/new_relic/control/frameworks/rails3.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 'new_relic/control/frameworks/rails'
 
@@ -13,9 +13,8 @@ module NewRelic
       # NewRelic::Control::Frameworks::Rails class, where the two do
       # not differ
       class Rails3 < NewRelic::Control::Frameworks::Rails
-
         def env
-          @env ||= ( ENV['NEW_RELIC_ENV'] || ::Rails.env.to_s )
+          @env ||= (ENV['NEW_RELIC_ENV'] || ::Rails.env.to_s)
         end
 
         def rails_root
@@ -23,7 +22,7 @@ module NewRelic
         end
 
         def vendor_root
-          @vendor_root ||= File.join(root,'vendor','rails')
+          @vendor_root ||= File.join(root, 'vendor', 'rails')
         end
 
         def version

data/lib/new_relic/control/frameworks/rails4.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 'new_relic/control/frameworks/rails3'
 

data/lib/new_relic/control/frameworks/rails_notifications.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 'new_relic/control/frameworks/rails4'
 

data/lib/new_relic/control/frameworks/roda.rb

@@ -0,0 +1,20 @@
+# 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/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Roda
+      class Roda < NewRelic::Control::Frameworks::Ruby
+        protected
+
+        def install_shim
+          super
+          ::Roda.class_eval { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/control/frameworks/ruby.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
   class Control
@@ -9,14 +9,14 @@ module NewRelic
       class Ruby < NewRelic::Control
         def env
           @env ||= ENV['NEW_RELIC_ENV'] || ENV['RUBY_ENV'] || ENV['RAILS_ENV'] ||
-                   ENV['APP_ENV']       || ENV['RACK_ENV'] || 'development'
+            ENV['APP_ENV'] || ENV['RACK_ENV'] || 'development'
         end
 
         def root
           @root ||= ENV['APP_ROOT'] || '.'
         end
 
-        def init_config(options={})
+        def init_config(options = {})
         end
       end
     end

data/lib/new_relic/control/frameworks/sinatra.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 'new_relic/control/frameworks/ruby'
 module NewRelic
@@ -8,6 +8,12 @@ module NewRelic
     module Frameworks
       # Contains basic control logic for Sinatra
       class Sinatra < NewRelic::Control::Frameworks::Ruby
+        protected
+
+        def install_shim
+          super
+          ::Sinatra::Base.class_eval { include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim }
+        end
       end
     end
   end

data/lib/new_relic/control/frameworks.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
   class Control

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,15 @@ 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
-
-        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 +80,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 +95,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 +147,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,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