newrelic_rpm 8.13.1 → 8.15.0

data/lib/sequel/extensions/newrelic_instrumentation.rb

@@ -54,7 +54,7 @@ module Sequel
         super(*args, &blk)
       ensure
         notice_sql(sql)
-        segment.finish if segment
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
       end
     end
 

data/lib/sequel/plugins/newrelic_instrumentation.rb

@@ -30,7 +30,7 @@ module Sequel
             begin
               NewRelic::Agent.disable_all_tracing { super(*args, &block) }
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         end

data/newrelic.yml

@@ -26,6 +26,13 @@ common: &default_settings
   # All of the following configuration options are optional. Review them, and
   # uncomment or edit them if they appear relevant to your application needs.
 
+  # An array of ActiveSupport custom events names to subscribe to and provide
+  # instrumentation for. For example,
+  #   - my.custom.event
+  #   - another.event
+  #   - a.third.event
+  # active_support_custom_events_names: ""
+
   # If `true`, all logging-related features for the agent can be enabled or disabled
   # independently. If `false`, all logging-related features are disabled.
   # application_logging.enabled: true
@@ -155,6 +162,10 @@ common: &default_settings
   # or  port_path_or_id parameters to transaction or slow SQL traces.
   # datastore_tracer.instance_reporting.enabled: true
 
+  # If true, when the agent is in an application using Ruby on Rails, it will start after
+  # config/initializers have run.
+  # defer_rails_initialization: false
+
   # If true, disables Action Cable instrumentation.
   # disable_action_cable_instrumentation: false
 
@@ -173,6 +184,9 @@ common: &default_settings
   # If true, the agent won't sample the CPU usage of the host process.
   # disable_cpu_sampler: false
 
+  # If true, disables ActiveSupport custom events instrumentation.
+  # disable_custom_events_instrumentation: false
+
   # If true, disables DataMapper instrumentation.
   # disable_data_mapper: false
 
@@ -303,17 +317,21 @@ common: &default_settings
 
   # Configure the compression level for data sent to the Trace Observer
   # May be one of [none|low|medium|high]
-  # By default, compression is not used (level = none)
-  # infinite_tracing.compression_level: none
+  # 'high' is the default. Set the level to 'none' to disable compression
+  # infinite_tracing.compression_level: high
 
-  # If true, data sent to the Trace Observer will be batched instead of
-  # the default of each span being sent individually
-  # infinite_tracing.batching: false
+  # If true (the default), data sent to the Trace Observer will be batched
+  # instead of each span being sent individually
+  # infinite_tracing.batching: true
 
   # Controls auto-instrumentation of bunny at start up.
   # May be one of [auto|prepend|chain|disabled].
   # instrumentation.bunny: auto
 
+  # Controls auto-instrumentation of concurrent_ruby at start up.
+  # May be one of [auto|prepend|chain|disabled]
+  # instrumentation.concurrent_ruby: auto
+
   # Controls auto-instrumentation of Curb at start up.
   # May be one of [auto|prepend|chain|disabled].
   # instrumentation.curb: auto

data/test/agent_helper.rb

@@ -31,7 +31,7 @@ def fake_guid(length = 16)
 end
 
 def assert_between(floor, ceiling, value, message = "expected #{floor} <= #{value} <= #{ceiling}")
-  assert((floor <= value && value <= ceiling), message) # rubocop:disable Minitest/AssertWithExpectedArgument
+  assert((floor <= value && value <= ceiling), message)
 end
 
 def assert_in_delta(expected, actual, delta)
@@ -236,7 +236,7 @@ def assert_metrics_recorded(expected)
       msg += "\nDid find specs: [\n#{matches.join(",\n")}\n]" unless matches.empty?
       msg += "\nAll specs in there were: #{format_metric_spec_list(all_specs)}"
 
-      assert(actual_stats, msg) # rubocop:disable Minitest/AssertWithExpectedArgument
+      assert(actual_stats, msg)
     end
 
     assert_stats_has_values(actual_stats, expected_spec, expected_attrs)
@@ -844,7 +844,7 @@ ensure
 end
 
 def json_dump_and_encode(object)
-  Base64.encode64(::JSON.dump(object))
+  Base64.encode64(JSON.dump(object))
 end
 
 def get_last_analytics_event
@@ -870,7 +870,7 @@ def load_cross_agent_test(name)
   test_file_path = File.join(cross_agent_tests_dir, "#{name}.json")
   data = File.read(test_file_path)
   data.gsub!('callCount', 'call_count')
-  data = ::JSON.load(data)
+  data = JSON.load(data)
   data.each { |testcase| testcase['testname'].tr!(' ', '_') if String === testcase['testname'] }
   data
 end
@@ -1014,9 +1014,9 @@ def assert_implements(instance, method, *args)
 end
 
 def defer_testing_to_min_supported_rails(test_file, min_rails_version, supports_jruby = true)
-  if defined?(::Rails) &&
-      defined?(::Rails::VERSION::STRING) &&
-      (::Rails::VERSION::STRING.to_f >= min_rails_version) &&
+  if defined?(Rails) &&
+      defined?(Rails::VERSION::STRING) &&
+      (Rails::VERSION::STRING.to_f >= min_rails_version) &&
       (supports_jruby || !NewRelic::LanguageSupport.jruby?)
 
     yield

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 8.13.1
+  version: 8.15.0
 platform: ruby
 authors:
 - Tanna McClure
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-21 00:00:00.000000000 Z
+date: 2023-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -162,10 +162,13 @@ files:
 - lib/new_relic/agent.rb
 - lib/new_relic/agent/adaptive_sampler.rb
 - lib/new_relic/agent/agent.rb
-- lib/new_relic/agent/agent/shutdown.rb
-- lib/new_relic/agent/agent/special_startup.rb
-- lib/new_relic/agent/agent/start_worker_thread.rb
-- lib/new_relic/agent/agent/startup.rb
+- lib/new_relic/agent/agent_helpers/connect.rb
+- lib/new_relic/agent/agent_helpers/harvest.rb
+- lib/new_relic/agent/agent_helpers/shutdown.rb
+- lib/new_relic/agent/agent_helpers/special_startup.rb
+- lib/new_relic/agent/agent_helpers/start_worker_thread.rb
+- lib/new_relic/agent/agent_helpers/startup.rb
+- lib/new_relic/agent/agent_helpers/transmit.rb
 - lib/new_relic/agent/agent_logger.rb
 - lib/new_relic/agent/attribute_filter.rb
 - lib/new_relic/agent/attribute_processing.rb
@@ -249,6 +252,7 @@ files:
 - lib/new_relic/agent/instrumentation/active_record_subscriber.rb
 - lib/new_relic/agent/instrumentation/active_storage.rb
 - lib/new_relic/agent/instrumentation/active_storage_subscriber.rb
+- lib/new_relic/agent/instrumentation/active_support.rb
 - lib/new_relic/agent/instrumentation/active_support_logger.rb
 - lib/new_relic/agent/instrumentation/active_support_logger/chain.rb
 - lib/new_relic/agent/instrumentation/active_support_logger/instrumentation.rb
@@ -259,11 +263,16 @@ files:
 - lib/new_relic/agent/instrumentation/bunny/chain.rb
 - lib/new_relic/agent/instrumentation/bunny/instrumentation.rb
 - lib/new_relic/agent/instrumentation/bunny/prepend.rb
+- lib/new_relic/agent/instrumentation/concurrent_ruby.rb
+- lib/new_relic/agent/instrumentation/concurrent_ruby/chain.rb
+- lib/new_relic/agent/instrumentation/concurrent_ruby/instrumentation.rb
+- lib/new_relic/agent/instrumentation/concurrent_ruby/prepend.rb
 - lib/new_relic/agent/instrumentation/controller_instrumentation.rb
 - lib/new_relic/agent/instrumentation/curb.rb
 - lib/new_relic/agent/instrumentation/curb/chain.rb
 - lib/new_relic/agent/instrumentation/curb/instrumentation.rb
 - lib/new_relic/agent/instrumentation/curb/prepend.rb
+- lib/new_relic/agent/instrumentation/custom_events_subscriber.rb
 - lib/new_relic/agent/instrumentation/data_mapper.rb
 - lib/new_relic/agent/instrumentation/delayed_job/chain.rb
 - lib/new_relic/agent/instrumentation/delayed_job/instrumentation.rb
@@ -334,6 +343,7 @@ files:
 - lib/new_relic/agent/instrumentation/rails_notifications/action_cable.rb
 - lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb
 - lib/new_relic/agent/instrumentation/rails_notifications/action_view.rb
+- lib/new_relic/agent/instrumentation/rails_notifications/custom_events.rb
 - lib/new_relic/agent/instrumentation/rainbows_instrumentation.rb
 - lib/new_relic/agent/instrumentation/rake.rb
 - lib/new_relic/agent/instrumentation/rake/chain.rb

data/lib/new_relic/agent/agent/shutdown.rb

@@ -1,35 +0,0 @@
-# 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 Agent
-    module Shutdown
-      # Attempt a graceful shutdown of the agent, flushing any remaining
-      # data.
-      def shutdown
-        return unless started?
-
-        ::NewRelic::Agent.logger.info("Starting Agent shutdown")
-
-        stop_event_loop
-        trap_signals_for_litespeed
-        untraced_graceful_disconnect
-        revert_to_default_configuration
-
-        @started = nil
-        Control.reset
-      end
-
-      def untraced_graceful_disconnect
-        begin
-          NewRelic::Agent.disable_all_tracing do
-            graceful_disconnect
-          end
-        rescue => e
-          ::NewRelic::Agent.logger.error(e)
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/agent/special_startup.rb

@@ -1,72 +0,0 @@
-# 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 Agent
-    module SpecialStartup
-      # If we're using a dispatcher that forks before serving
-      # requests, we need to wait until the children are forked
-      # before connecting, otherwise the parent process sends useless data
-      def using_forking_dispatcher?
-        # TODO: MAJOR VERSION - remove :rainbows
-        if [:puma, :passenger, :rainbows, :unicorn].include?(Agent.config[:dispatcher])
-          ::NewRelic::Agent.logger.info("Deferring startup of agent reporting thread because #{Agent.config[:dispatcher]} may fork.")
-          true
-        else
-          false
-        end
-      end
-
-      # Return true if we're using resque and it hasn't had a chance to (potentially)
-      # daemonize itself. This avoids hanging when there's a Thread started
-      # before Resque calls Process.daemon (Jira RUBY-857)
-      def defer_for_resque?
-        NewRelic::Agent.config[:dispatcher] == :resque &&
-          NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job? &&
-          !PipeChannelManager.listener.started?
-      end
-
-      def in_resque_child_process?
-        defined?(@service) && @service.is_a?(PipeService)
-      end
-
-      def defer_for_delayed_job?
-        NewRelic::Agent.config[:dispatcher] == :delayed_job &&
-          !NewRelic::DelayedJobInjection.worker_name
-      end
-
-      # This matters when the following three criteria are met:
-      #
-      # 1. A Sinatra 'classic' application is being run
-      # 2. The app is being run by executing the main file directly, rather
-      #    than via a config.ru file.
-      # 3. newrelic_rpm is required *after* sinatra
-      #
-      # In this case, the entire application runs from an at_exit handler in
-      # Sinatra, and if we were to install ours, it would be executed before
-      # the one in Sinatra, meaning that we'd shutdown the agent too early
-      # and never collect any data.
-      def sinatra_classic_app?
-        (
-          defined?(Sinatra::Application) &&
-          Sinatra::Application.respond_to?(:run) &&
-          Sinatra::Application.run?
-        )
-      end
-
-      def should_install_exit_handler?
-        return false unless Agent.config[:send_data_on_exit]
-
-        !sinatra_classic_app? || Agent.config[:force_install_exit_handler]
-      end
-
-      def install_exit_handler
-        return unless should_install_exit_handler?
-
-        NewRelic::Agent.logger.debug("Installing at_exit handler")
-        at_exit { shutdown }
-      end
-    end
-  end
-end

data/lib/new_relic/agent/agent/start_worker_thread.rb

@@ -1,163 +0,0 @@
-# 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 Agent
-    module StartWorkerThread
-      LOG_ONCE_KEYS_RESET_PERIOD = 60.0
-
-      TRANSACTION_EVENT_DATA = "transaction_event_data".freeze
-      CUSTOM_EVENT_DATA = "custom_event_data".freeze
-      ERROR_EVENT_DATA = "error_event_data".freeze
-      SPAN_EVENT_DATA = "span_event_data".freeze
-      LOG_EVENT_DATA = "log_event_data".freeze
-
-      # Try to launch the worker thread and connect to the server.
-      #
-      # See #connect for a description of connection_options.
-      def start_worker_thread(connection_options = {})
-        if disable = NewRelic::Agent.config[:disable_harvest_thread]
-          NewRelic::Agent.logger.info("Not starting Ruby Agent worker thread because :disable_harvest_thread is #{disable}")
-          return
-        end
-
-        ::NewRelic::Agent.logger.debug("Creating Ruby Agent worker thread.")
-        @worker_thread = Threading::AgentThread.create('Worker Loop') do
-          deferred_work!(connection_options)
-        end
-      end
-
-      def create_event_loop
-        EventLoop.new
-      end
-
-      # If the @worker_thread encounters an error during the attempt to connect to the collector
-      # then the connect attempts enter an exponential backoff retry loop.  To avoid potential
-      # race conditions with shutting down while also attempting to reconnect, we join the
-      # @worker_thread with a timeout threshold.  This allows potentially connecting and flushing
-      # pending data to the server, but without waiting indefinitely for a reconnect to succeed.
-      # The use-case where this typically arises is in cronjob scheduled rake tasks where there's
-      # also some network stability/latency issues happening.
-      def stop_event_loop
-        @event_loop.stop if @event_loop
-        # Wait the end of the event loop thread.
-        if @worker_thread
-          unless @worker_thread.join(3)
-            ::NewRelic::Agent.logger.debug("Event loop thread did not stop within 3 seconds")
-          end
-        end
-      end
-
-      # Certain event types may sometimes need to be on the same interval as metrics,
-      # so we will check config assigned in EventHarvestConfig to determine the interval
-      # on which to report them
-      def interval_for(event_type)
-        interval = Agent.config[:"event_report_period.#{event_type}"]
-        :"#{interval}_second_harvest"
-      end
-
-      def create_and_run_event_loop
-        data_harvest = :"#{Agent.config[:data_report_period]}_second_harvest"
-        event_harvest = :"#{Agent.config[:event_report_period]}_second_harvest"
-
-        @event_loop = create_event_loop
-        @event_loop.on(data_harvest) do
-          transmit_data
-        end
-
-        @event_loop.on(interval_for(TRANSACTION_EVENT_DATA)) do
-          transmit_analytic_event_data
-        end
-        @event_loop.on(interval_for(CUSTOM_EVENT_DATA)) do
-          transmit_custom_event_data
-        end
-        @event_loop.on(interval_for(ERROR_EVENT_DATA)) do
-          transmit_error_event_data
-        end
-        @event_loop.on(interval_for(SPAN_EVENT_DATA)) do
-          transmit_span_event_data
-        end
-        @event_loop.on(interval_for(LOG_EVENT_DATA)) do
-          transmit_log_event_data
-        end
-
-        @event_loop.on(:reset_log_once_keys) do
-          ::NewRelic::Agent.logger.clear_already_logged
-        end
-        @event_loop.fire_every(Agent.config[:data_report_period], data_harvest)
-        @event_loop.fire_every(Agent.config[:event_report_period], event_harvest)
-        @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD, :reset_log_once_keys)
-
-        @event_loop.run
-      end
-
-      # Handles the case where the server tells us to restart -
-      # this clears the data, clears connection attempts, and
-      # waits a while to reconnect.
-      def handle_force_restart(error)
-        ::NewRelic::Agent.logger.debug(error.message)
-        drop_buffered_data
-        @service.force_restart if @service
-        @connect_state = :pending
-        sleep(30)
-      end
-
-      # when a disconnect is requested, stop the current thread, which
-      # is the worker thread that gathers data and talks to the
-      # server.
-      def handle_force_disconnect(error)
-        ::NewRelic::Agent.logger.warn("Agent received a ForceDisconnectException from the server, disconnecting. (#{error.message})")
-        disconnect
-      end
-
-      # Handles an unknown error in the worker thread by logging
-      # it and disconnecting the agent, since we are now in an
-      # unknown state.
-      def handle_other_error(error)
-        ::NewRelic::Agent.logger.error("Unhandled error in worker thread, disconnecting.")
-        # These errors are fatal (that is, they will prevent the agent from
-        # reporting entirely), so we really want backtraces when they happen
-        ::NewRelic::Agent.logger.log_exception(:error, error)
-        disconnect
-      end
-
-      # a wrapper method to handle all the errors that can happen
-      # in the connection and worker thread system. This
-      # guarantees a no-throw from the background thread.
-      def catch_errors
-        yield
-      rescue NewRelic::Agent::ForceRestartException => e
-        handle_force_restart(e)
-        retry
-      rescue NewRelic::Agent::ForceDisconnectException => e
-        handle_force_disconnect(e)
-      rescue => e
-        handle_other_error(e)
-      end
-
-      # This is the method that is run in a new thread in order to
-      # background the harvesting and sending of data during the
-      # normal operation of the agent.
-      #
-      # Takes connection options that determine how we should
-      # connect to the server, and loops endlessly - typically we
-      # never return from this method unless we're shutting down
-      # the agent
-      def deferred_work!(connection_options)
-        catch_errors do
-          NewRelic::Agent.disable_all_tracing do
-            connect(connection_options)
-            if connected?
-              create_and_run_event_loop
-              # never reaches here unless there is a problem or
-              # the agent is exiting
-            else
-              ::NewRelic::Agent.logger.debug("No connection.  Worker thread ending.")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/agent/startup.rb

@@ -1,197 +0,0 @@
-# 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 Agent
-    module Startup
-      # True if we have initialized and completed 'start'
-      def started?
-        @started
-      end
-
-      # Check whether we have already started, which is an error condition
-      def already_started?
-        if started?
-          ::NewRelic::Agent.logger.error("Agent Started Already!")
-          true
-        end
-      end
-
-      # Logs a bunch of data and starts the agent, if needed
-      def start
-        return unless agent_should_start?
-
-        log_startup
-        check_config_and_start_agent
-        log_version_and_pid
-
-        events.subscribe(:initial_configuration_complete) do
-          log_ignore_url_regexes
-        end
-      end
-
-      # Sanity-check the agent configuration and start the agent,
-      # setting up the worker thread and the exit handler to shut
-      # down the agent
-      def check_config_and_start_agent
-        return unless monitoring? && has_correct_license_key?
-        return if using_forking_dispatcher?
-
-        setup_and_start_agent
-      end
-
-      # This is the shared method between the main agent startup and the
-      # after_fork call restarting the thread in deferred dispatchers.
-      #
-      # Treatment of @started and env report is important to get right.
-      def setup_and_start_agent(options = {})
-        @started = true
-        @harvester.mark_started
-
-        unless in_resque_child_process?
-          install_exit_handler
-          environment_for_connect
-          @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
-        end
-
-        connect_in_foreground if Agent.config[:sync_startup]
-        start_worker_thread(options)
-      end
-
-      # Log startup information that we almost always want to know
-      def log_startup
-        log_environment
-        log_dispatcher
-        log_app_name
-      end
-
-      # Log the environment the app thinks it's running in.
-      # Useful in debugging, as this is the key for config YAML lookups.
-      def log_environment
-        ::NewRelic::Agent.logger.info("Environment: #{NewRelic::Control.instance.env}")
-      end
-
-      # Logs the dispatcher to the log file to assist with
-      # debugging. When no debugger is present, logs this fact to
-      # assist with proper dispatcher detection
-      def log_dispatcher
-        dispatcher_name = Agent.config[:dispatcher].to_s
-
-        if dispatcher_name.empty?
-          ::NewRelic::Agent.logger.info('No known dispatcher detected.')
-        else
-          ::NewRelic::Agent.logger.info("Dispatcher: #{dispatcher_name}")
-        end
-      end
-
-      def log_app_name
-        ::NewRelic::Agent.logger.info("Application: #{Agent.config[:app_name].join(", ")}")
-      end
-
-      def log_ignore_url_regexes
-        regexes = NewRelic::Agent.config[:'rules.ignore_url_regexes']
-
-        unless regexes.empty?
-          ::NewRelic::Agent.logger.info("Ignoring URLs that match the following regexes: #{regexes.map(&:inspect).join(", ")}.")
-        end
-      end
-
-      # Classy logging of the agent version and the current pid,
-      # so we can disambiguate processes in the log file and make
-      # sure they're running a reasonable version
-      def log_version_and_pid
-        ::NewRelic::Agent.logger.debug("New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}")
-      end
-
-      # Logs the configured application names
-      def app_name_configured?
-        names = Agent.config[:app_name]
-        return names.respond_to?(:any?) && names.any?
-      end
-
-      # Connecting in the foreground blocks further startup of the
-      # agent until we have a connection - useful in cases where
-      # you're trying to log a very-short-running process and want
-      # to get statistics from before a server connection
-      # (typically 20 seconds) exists
-      def connect_in_foreground
-        NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
-      end
-
-      # Warn the user if they have configured their agent not to
-      # send data, that way we can see this clearly in the log file
-      def monitoring?
-        if Agent.config[:monitor_mode]
-          true
-        else
-          ::NewRelic::Agent.logger.warn('Agent configured not to send data in this environment.')
-          false
-        end
-      end
-
-      # Tell the user when the license key is missing so they can
-      # fix it by adding it to the file
-      def has_license_key?
-        if Agent.config[:license_key] && Agent.config[:license_key].length > 0
-          true
-        else
-          ::NewRelic::Agent.logger.warn("No license key found. " +
-            "This often means your newrelic.yml file was not found, or it lacks a section for the running environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml to ensure it is valid YML.")
-          false
-        end
-      end
-
-      # A correct license key exists and is of the proper length
-      def has_correct_license_key?
-        has_license_key? && correct_license_length
-      end
-
-      # A license key is an arbitrary 40 character string,
-      # usually looks something like a SHA1 hash
-      def correct_license_length
-        key = Agent.config[:license_key]
-
-        if key.length == 40
-          true
-        else
-          ::NewRelic::Agent.logger.error("Invalid license key: #{key}")
-          false
-        end
-      end
-
-      # Check to see if the agent should start, returning +true+ if it should.
-      def agent_should_start?
-        return false if already_started? || disabled?
-
-        if defer_for_delayed_job?
-          ::NewRelic::Agent.logger.debug("Deferring startup for DelayedJob")
-          return false
-        end
-
-        if defer_for_resque?
-          ::NewRelic::Agent.logger.debug("Deferring startup for Resque in case it daemonizes")
-          return false
-        end
-
-        unless app_name_configured?
-          NewRelic::Agent.logger.error("No application name configured.",
-            "The Agent cannot start without at least one. Please check your ",
-            "newrelic.yml and ensure that it is valid and has at least one ",
-            "value set for app_name in the #{NewRelic::Control.instance.env} ",
-            "environment.")
-          return false
-        end
-
-        return true
-      end
-
-      # The agent is disabled when it is not force enabled by the
-      # 'agent_enabled' option (e.g. in a manual start), or
-      # enabled normally through the configuration file
-      def disabled?
-        !Agent.config[:agent_enabled]
-      end
-    end
-  end
-end