newrelic_rpm 8.13.1 → 8.14.0

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