oneapm_rpm 1.1.2 → 1.1.3

data/lib/one_apm/agent/agent/container_data_manager.rb

@@ -19,7 +19,7 @@ module OneApm
             container_for_endpoint(endpoint).merge!(data)
           end
         rescue => e
-          OneApm::Agent.logger.error("Error while merging #{endpoint} data from child: ", e)
+          OneApm::Manager.logger.error("Error while merging #{endpoint} data from child: ", e)
         end
 
         # Clear out the metric data, errors, and transaction traces, etc.
@@ -83,27 +83,27 @@ module OneApm
           begin
             items = container.harvest!
           rescue => e
-            OneApm::Agent.logger.error("Failed to harvest #{endpoint} data, resetting. Error: ", e)
+            OneApm::Manager.logger.error("Failed to harvest #{endpoint} data, resetting. Error: ", e)
             container.reset!
           end
           items
         end
 
         def send_data_to_endpoint(endpoint, items, container)
-          OneApm::Agent.logger.debug("Sending #{items.size} items to #{endpoint}")
+          OneApm::Manager.logger.debug("Sending #{items.size} items to #{endpoint}")
           begin
             @service.send(endpoint, items)
           rescue ForceRestartException, ForceDisconnectException
             raise
           rescue SerializationError => e
-            OneApm::Agent.logger.warn("Failed to serialize data for #{endpoint}, discarding. Error: ", e)
+            OneApm::Manager.logger.warn("Failed to serialize data for #{endpoint}, discarding. Error: ", e)
           rescue UnrecoverableServerException => e
-            OneApm::Agent.logger.warn("#{endpoint} data was rejected by remote service, discarding. Error: ", e)
+            OneApm::Manager.logger.warn("#{endpoint} data was rejected by remote service, discarding. Error: ", e)
           rescue ServerConnectionException => e
             log_remote_unavailable(endpoint, e)
             container.merge!(items)
           rescue => e
-            OneApm::Agent.logger.info("Unable to send #{endpoint} data, will try again later. Error: ", e)
+            OneApm::Manager.logger.info("Unable to send #{endpoint} data, will try again later. Error: ", e)
             container.merge!(items)
           end
         end
@@ -161,7 +161,7 @@ module OneApm
           now = Time.now
 
           msg = "Sending #{harvest_method.to_s.gsub("harvest_and_send_", "")} to OneApm Service"
-          ::OneApm::Agent.logger.debug msg
+          OneApm::Manager.logger.debug msg
 
           harvest_lock.synchronize do
             @service.session do # use http keep-alive
@@ -170,13 +170,13 @@ module OneApm
           end
         ensure
           duration = (Time.now - now).to_f
-          OneApm::Agent.record_metric("Supportability/#{supportability_name}Harvest", duration)
+          OneApm::Manager.record_metric("Supportability/#{supportability_name}Harvest", duration)
         end
 
         # This method is expected to only be called with the harvest_lock already held
         def transmit_data_already_locked
           now = Time.now
-          ::OneApm::Agent.logger.debug "Sending data to OneApm Service"
+          OneApm::Manager.logger.debug "Sending data to OneApm Service"
 
           @events.notify(:before_harvest)
           @service.session do
@@ -191,7 +191,7 @@ module OneApm
         ensure
           OneApm::Agent::Database.close_connections
           duration = (Time.now - now).to_f
-          OneApm::Agent.record_metric('Supportability/Harvest', duration)
+          OneApm::Manager.record_metric('Supportability/Harvest', duration)
         end
 
         def check_for_and_handle_agent_commands
@@ -202,14 +202,14 @@ module OneApm
           rescue ServerConnectionException => e
             log_remote_unavailable(:get_agent_commands, e)
           rescue => e
-            OneApm::Agent.logger.info("Error during check_for_and_handle_agent_commands, will retry later: ", e)
+            OneApm::Manager.logger.info("Error during check_for_and_handle_agent_commands, will retry later: ", e)
           end
         end
 
         def log_remote_unavailable(endpoint, e)
-          OneApm::Agent.logger.debug("Unable to send #{endpoint} data, will try again later. Error: ", e)
-          OneApm::Agent.record_metric("Supportability/remote_unavailable", 0.0)
-          OneApm::Agent.record_metric("Supportability/remote_unavailable/#{endpoint.to_s}", 0.0)
+          OneApm::Manager.logger.debug("Unable to send #{endpoint} data, will try again later. Error: ", e)
+          OneApm::Manager.record_metric("Supportability/remote_unavailable", 0.0)
+          OneApm::Manager.record_metric("Supportability/remote_unavailable/#{endpoint.to_s}", 0.0)
         end
 
       end

data/lib/one_apm/agent/agent/forkable_dispatcher_functions.rb

@@ -3,25 +3,6 @@ module OneApm
     class Agent
       module ForkableDispatcherFunctions
 
-        # This method should be called in a forked process after a fork.
-        # It assumes the parent process initialized the agent, but does
-        # not assume the agent started.
-        #
-        # The call is idempotent, but not re-entrant.
-        #
-        # * It clears any metrics carried over from the parent process
-        # * Restarts the sampler thread if necessary
-        # * Initiates a new agent run and worker loop unless that was done
-        #   in the parent process and +:force_reconnect+ is not true
-        #
-        # Options:
-        # * <tt>:force_reconnect => true</tt> to force the spawned process to
-        #   establish a new connection, such as when forking a long running process.
-        #   The default is false--it will only connect to the server if the parent
-        #   had not connected.
-        # * <tt>:keep_retrying => false</tt> if we try to initiate a new
-        #   connection, this tells me to only try it once so this method returns
-        #   quickly if there is some kind of latency with the server.
         def after_fork(options={})
           needs_restart = false
           @after_fork_lock.synchronize do
@@ -30,16 +11,15 @@ module OneApm
           end
 
           return if !needs_restart ||
-            !Agent.config[:agent_enabled] ||
-            !Agent.config[:monitor_mode] ||
+            !Manager.config[:agent_enabled] ||
+            !Manager.config[:monitor_mode] ||
             disconnected?
 
-          ::OneApm::Agent.logger.debug "Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking."
+          OneApm::Manager.logger.debug "Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking."
 
           channel_id = options[:report_to_channel]
           install_pipe_service(channel_id) if channel_id
 
-          # Clear out locks and stats left over from parent process
           reset_objects_with_locks
           drop_buffered_data
 
@@ -47,36 +27,27 @@ module OneApm
         end
 
         def install_pipe_service(channel_id)
-          @service = OneApm::Agent::PipeService.new(channel_id)
+          @service = OneApm::Agent::ForkedProcessService.new(channel_id)
           if connected?
             @connected_pid = Process.pid
           else
-            ::OneApm::Agent.logger.debug("Child process #{Process.pid} not reporting to non-connected parent (process #{Process.ppid}).")
+            OneApm::Manager.logger.debug("Child process #{Process.pid} not reporting to non-connected parent (process #{Process.ppid}).")
             @service.shutdown(Time.now)
             disconnect
           end
         end
 
-        # Synchronize with the harvest loop. If the harvest thread has taken
-        # a lock (DNS lookups, backticks, agent-owned locks, etc), and we
-        # fork while locked, this can deadlock child processes. For more
-        # details, see https://github.com/resque/resque/issues/1101
         def synchronize_with_harvest
           harvest_lock.synchronize do
             yield
           end
         end
 
-        # Clear out state for any objects that we know lock from our parents
-        # This is necessary for cases where we're in a forked child and Ruby
-        # might be holding locks for background thread that aren't there anymore.
         def reset_objects_with_locks
           @stats_engine = OneApm::Collector::StatsEngine.new
           reset_harvest_locks
         end
 
-        # Some forking cases (like Resque) end up with harvest lock from the
-        # parent process orphaned in the child. Let it go before we proceed.
         def reset_harvest_locks
           return if harvest_lock.nil?
 
@@ -84,7 +55,7 @@ module OneApm
         end
 
         def flush_pipe_data
-          if connected? && @service.is_a?(::OneApm::Agent::PipeService)
+          if connected? && @service.is_a?(::OneApm::Agent::ForkedProcessService)
             transmit_data
             transmit_event_data
           end

data/lib/one_apm/agent/agent/helpers.rb

@@ -6,40 +6,29 @@ module OneApm
         def obfuscator
           @obfuscator ||= lambda {|sql| OneApm::Agent::Database.default_sql_obfuscator(sql) }
         end
-        # Sets a thread local variable as to whether we should or
-        # should not record sql in the current thread. Returns the
-        # previous value, if there is one
-        def set_record_sql(should_record) #THREAD_LOCAL_ACCESS
+
+        def set_record_sql(should_record)
           state = TransactionState.tl_get
           prev = state.record_sql
           state.record_sql = should_record
           prev.nil? || prev
         end
 
-        # Sets a thread local variable as to whether we should or
-        # should not record transaction traces in the current
-        # thread. Returns the previous value, if there is one
-        def set_record_tt(should_record) #THREAD_LOCAL_ACCESS
+        def set_record_tt(should_record)
           state = TransactionState.tl_get
           prev = state.record_tt
           state.record_tt = should_record
           prev.nil? || prev
         end
 
-        # Push flag indicating whether we should be tracing in this
-        # thread. This uses a stack which allows us to disable tracing
-        # children of a transaction without affecting the tracing of
-        # the whole transaction
-        def push_trace_execution_flag(should_trace=false) #THREAD_LOCAL_ACCESS
+        def push_trace_execution_flag(should_trace=false)
           TransactionState.tl_get.push_traced(should_trace)
         end
 
-        # Pop the current trace execution status.  Restore trace execution status
-        # to what it was before we pushed the current flag.
-        def pop_trace_execution_flag #THREAD_LOCAL_ACCESS
+        def pop_trace_execution_flag
           TransactionState.tl_get.pop_traced
         end
       end
     end
   end
-end
+end

data/lib/one_apm/agent/agent/start.rb

@@ -25,10 +25,10 @@ module OneApm
           unless in_resque_child_process?
             generate_environment_report
             install_exit_handler
-            @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
+            @harvest_samplers.load_samplers unless OneApm::Manager.config[:disable_samplers]
           end
 
-          connect_in_foreground if Agent.config[:sync_startup]
+          connect_in_foreground if OneApm::Manager.config[:sync_startup]
           start_worker_thread(options)
         end
 
@@ -40,7 +40,7 @@ module OneApm
         # Check whether we have already started, which is an error condition
         def already_started?
           if started?
-            ::OneApm::Agent.logger.error("Agent Started Already!")
+            OneApm::Manager.logger.error("Agent Started Already!")
             true
           end
         end
@@ -49,7 +49,7 @@ module OneApm
         # behavior of at_exit blocks to make sure it runs last, by
         # doing an at_exit within an at_exit block.
         def install_exit_handler
-          if Agent.config[:send_data_on_exit] && !weird_ruby?
+          if OneApm::Manager.config[:send_data_on_exit] && !weird_ruby?
             at_exit do
               # Workaround for MRI 1.9 bug that loses exit codes in at_exit blocks.
               # This is necessary to get correct exit codes for the agent's
@@ -70,12 +70,12 @@ module OneApm
         # 'agent_enabled' option (e.g. in a manual start), or
         # enabled normally through the configuration file
         def disabled?
-          !Agent.config[:agent_enabled]
+          !Manager.config[:agent_enabled]
         end
 
         # Logs the configured application names
         def app_name_configured?
-          names = Agent.config.app_names
+          names = OneApm::Manager.config.app_names
           return names.respond_to?(:any?) && names.any?
         end
 
@@ -85,7 +85,7 @@ module OneApm
         # to get statistics from before a server connection
         # (typically 20 seconds) exists
         def connect_in_foreground
-          OneApm::Agent.disable_all_tracing { connect(:keep_retrying => false) }
+          OneApm::Manager.disable_all_tracing { connect(:keep_retrying => false) }
         end
 
         # If we're using sinatra, old versions run in an at_exit
@@ -105,10 +105,10 @@ module OneApm
         # 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]
+          if OneApm::Manager.config[:monitor_mode]
             true
           else
-            ::OneApm::Agent.logger.warn('Agent configured not to send data in this environment.')
+            OneApm::Manager.logger.warn('Agent configured not to send data in this environment.')
             false
           end
         end
@@ -116,10 +116,10 @@ module OneApm
         # 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
+          if OneApm::Manager.config[:license_key] && OneApm::Manager.config[:license_key].length > 0
             true
           else
-            ::OneApm::Agent.logger.warn("No license key found. " +
+            OneApm::Manager.logger.warn("No license key found. " +
               "This often means your oneapm.yml file was not found, or it lacks a section for the running environment, '#{OneApm::Probe.instance.env}'. You may also want to try linting your oneapm.yml to ensure it is valid YML.")
             false
           end
@@ -134,8 +134,8 @@ module OneApm
         # requests, we need to wait until the children are forked
         # before connecting, otherwise the parent process sends useless data
         def using_forking_dispatcher?
-          if [:puma, :passenger, :rainbows, :unicorn].include? Agent.config[:dispatcher]
-            ::OneApm::Agent.logger.info "Deferring startup of agent reporting thread because #{Agent.config[:dispatcher]} may fork."
+          if [:puma, :passenger, :rainbows, :unicorn].include? OneApm::Manager.config[:dispatcher]
+            OneApm::Manager.logger.info "Deferring startup of agent reporting thread because #{Manager.config[:dispatcher]} may fork."
             true
           else
             false
@@ -144,12 +144,12 @@ module OneApm
 
         def defer_for_background_jobs?
           if defer_for_delayed_job?
-            ::OneApm::Agent.logger.debug "Deferring startup for DelayedJob"
+            OneApm::Manager.logger.debug "Deferring startup for DelayedJob"
             return true
           end
 
           if defer_for_resque?
-            ::OneApm::Agent.logger.debug "Deferring startup for Resque in case it daemonizes"
+            OneApm::Manager.logger.debug "Deferring startup for Resque in case it daemonizes"
             return true
           end
 
@@ -159,7 +159,7 @@ module OneApm
         require 'one_apm/inst/background_job/delayed_job_injection'
 
         def defer_for_delayed_job?
-          OneApm::Agent.config[:dispatcher] == :delayed_job &&
+          OneApm::Manager.config[:dispatcher] == :delayed_job &&
             !OneApm::DelayedJobInjection.worker_name
         end
 
@@ -167,13 +167,13 @@ module OneApm
         # daemonize itself. This avoids hanging when there's a Thread started
         # before Resque calls Process.daemon (Jira RUBY-857)
         def defer_for_resque?
-          OneApm::Agent.config[:dispatcher] == :resque &&
+          OneApm::Manager.config[:dispatcher] == :resque &&
             OneApm::LanguageSupport.can_fork? &&
-            !OneApm::Agent::PipeChannelManager.listener.started?
+            !OneApm::Support::ForkedProcessChannel.listener.started?
         end
 
         def in_resque_child_process?
-          @service.is_a?(OneApm::Agent::PipeService)
+          @service.is_a?(OneApm::Agent::ForkedProcessService)
         end
 
         # Log startup information that we almost always want to know
@@ -187,37 +187,37 @@ module OneApm
         # so we can disambiguate processes in the log file and make
         # sure they're running a reasonable version
         def log_version_and_pid
-          ::OneApm::Agent.logger.debug "OneApm Ruby Agent #{OneApm::VERSION::STRING} Initialized: pid = #{$$}"
+          OneApm::Manager.logger.debug "OneApm Ruby Agent #{OneApm::VERSION::STRING} Initialized: pid = #{$$}"
         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
-          ::OneApm::Agent.logger.info "Environment: #{OneApm::Probe.instance.env}"
+          OneApm::Manager.logger.info "Environment: #{OneApm::Probe.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
+          dispatcher_name = OneApm::Manager.config[:dispatcher].to_s
 
           if dispatcher_name.empty?
-            ::OneApm::Agent.logger.info 'No known dispatcher detected.'
+            OneApm::Manager.logger.info 'No known dispatcher detected.'
           else
-            ::OneApm::Agent.logger.info "Dispatcher: #{dispatcher_name}"
+            OneApm::Manager.logger.info "Dispatcher: #{dispatcher_name}"
           end
         end
 
         def log_app_name
-          ::OneApm::Agent.logger.info "Application: #{Agent.config.app_names.join(", ")}"
+          OneApm::Manager.logger.info "Application: #{Manager.config.app_names.join(", ")}"
         end
 
         def log_ignore_url_regexes
-          regexes = OneApm::Agent.config[:'rules.ignore_url_regexes']
+          regexes = OneApm::Manager.config[:'rules.ignore_url_regexes']
 
           unless regexes.empty?
-            ::OneApm::Agent.logger.info "Ignoring URLs that match the following regexes: #{regexes.map(&:inspect).join(", ")}."
+            OneApm::Manager.logger.info "Ignoring URLs that match the following regexes: #{regexes.map(&:inspect).join(", ")}."
           end
         end
       end

data/lib/one_apm/agent/agent/start_worker_thread.rb

@@ -1,50 +1,32 @@
 module OneApm
   module Agent
     class Agent
-      # All of this module used to be contained in the
-      # start_worker_thread method - this is an artifact of
-      # refactoring and can be moved, renamed, etc at will
       module StartWorkerThread
 
-        # Never allow any data type to be reported more frequently than once
-        # per second.
         MIN_ALLOWED_REPORT_PERIOD = 1.0
-        UTILIZATION_REPORT_PERIOD = 30 * 60 # every half hour
+        UTILIZATION_REPORT_PERIOD = 30 * 60
         LOG_ONCE_KEYS_RESET_PERIOD = 60.0
 
-        # 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 = OneApm::Agent.config[:disable_harvest_thread]
-            OneApm::Agent.logger.info "Not starting Ruby Agent worker thread because :disable_harvest_thread is #{disable}"
+          if disable = OneApm::Manager.config[:disable_harvest_thread]
+            OneApm::Manager.logger.info "Not starting Ruby Agent worker thread because :disable_harvest_thread is #{disable}"
             return
           end
 
-          ::OneApm::Agent.logger.info "Creating Ruby Agent worker thread."
+          OneApm::Manager.logger.debug "Creating Ruby Agent worker thread."
           @worker_thread = OneApm::Agent::Threading::AgentThread.create('Worker Loop') do
             deferred_work!(connection_options)
           end
         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
-            OneApm::Agent.disable_all_tracing do
+            OneApm::Manager.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
-                ::OneApm::Agent.logger.debug "No connection.  Worker thread ending."
+                OneApm::Manager.logger.debug "No connection.  Worker thread ending."
               end
             end
           end
@@ -55,13 +37,13 @@ module OneApm
 
           @event_loop.on(:report_data)          { transmit_data }
           @event_loop.on(:report_event_data)    { transmit_event_data }
-          @event_loop.on(:reset_log_once_keys)  { OneApm::Agent.logger.clear_already_logged }
+          @event_loop.on(:reset_log_once_keys)  { OneApm::Manager.logger.clear_already_logged }
 
-          @event_loop.fire_every(Agent.config[:data_report_period],       :report_data)
+          @event_loop.fire_every(Manager.config[:data_report_period],       :report_data)
           @event_loop.fire_every(report_period_for(:analytic_event_data), :report_event_data)
           @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD,              :reset_log_once_keys)
 
-          if Agent.config[:collect_utilization] && !in_resque_child_process?
+          if OneApm::Manager.config[:collect_utilization] && !in_resque_child_process?
             @event_loop.on(:report_utilization_data) { transmit_utilization_data }
 
             @event_loop.fire(:report_utilization_data)
@@ -72,18 +54,18 @@ module OneApm
         end
 
         def create_event_loop
-          EventLoop.new
+          OneApm::Support::EventLoop.new
         end
 
         def report_period_for(method)
           config_key = "data_report_periods.#{method}".to_sym
-          period = Agent.config[config_key]
+          period = OneApm::Manager.config[config_key]
           if !period
-            period = Agent.config[:data_report_period]
-            ::OneApm::Agent.logger.warn("Could not find configured period for #{method}, falling back to data_report_period (#{period} s)")
+            period = OneApm::Manager.config[:data_report_period]
+            OneApm::Manager.logger.warn("Could not find configured period for #{method}, falling back to data_report_period (#{period} s)")
           end
           if period < MIN_ALLOWED_REPORT_PERIOD
-            ::OneApm::Agent.logger.warn("Configured #{config_key} was #{period}, but minimum allowed is #{MIN_ALLOWED_REPORT_PERIOD}, using #{MIN_ALLOWED_REPORT_PERIOD}.")
+            OneApm::Manager.logger.warn("Configured #{config_key} was #{period}, but minimum allowed is #{MIN_ALLOWED_REPORT_PERIOD}, using #{MIN_ALLOWED_REPORT_PERIOD}.")
             period = MIN_ALLOWED_REPORT_PERIOD
           end
           period
@@ -91,16 +73,13 @@ module OneApm
 
         def stop_event_loop
           if @event_loop
-            @event_loop.run_once(true) if Agent.config[:force_send]
+            @event_loop.run_once(true) if OneApm::Manager.config[:force_send]
             @event_loop.stop
           end
         end
 
         private
 
-        # 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 OneApm::ForceRestartException => e
@@ -112,33 +91,22 @@ module OneApm
           handle_other_error(e)
         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)
-          ::OneApm::Agent.logger.debug error.message
+          OneApm::Manager.logger.debug error.message
           drop_buffered_data
           @service.reset_metric_id_cache 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)
-          ::OneApm::Agent.logger.warn "OneApm forced this agent to disconnect (#{error.message})"
+          OneApm::Manager.logger.warn "OneApm forced this agent to disconnect (#{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)
-          ::OneApm::Agent.logger.error "Unhandled error in worker thread, disconnecting this agent process:"
-          # These errors are fatal (that is, they will prevent the agent from
-          # reporting entirely), so we really want backtraces when they happen
-          ::OneApm::Agent.logger.log_exception(:error, error)
+          OneApm::Manager.logger.error "Unhandled error in worker thread, disconnecting this agent process:"
+          OneApm::Manager.logger.log_exception(:error, error)
           disconnect
         end