oneapm_rpm 1.1.0

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

@@ -0,0 +1,45 @@
+module OneApm
+  module Agent
+    class Agent
+      module Helpers
+
+        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
+          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
+          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
+          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
+          TransactionState.tl_get.pop_traced
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,226 @@
+module OneApm
+  module Agent
+    class Agent
+      # Herein lies the corpse of the former 'start' method. May
+      # its unmatched flog score rest in pieces.
+      module Start
+
+        # 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?
+            generate_environment_report
+            install_exit_handler
+            @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
+          end
+
+          connect_in_foreground if Agent.config[:sync_startup]
+          start_worker_thread(options)
+        end
+
+        # 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?
+            ::OneApm::Agent.logger.error("Agent Started Already!")
+            true
+          end
+        end
+
+        # Installs our exit handler, which exploits the weird
+        # 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?
+            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
+              # test suites.
+              # http://bugs.ruby-lang.org/issues/5218
+              if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION.match(/^1\.9/)
+                exit_status = $!.status if $!.is_a?(SystemExit)
+                shutdown
+                exit exit_status if exit_status
+              else
+                shutdown
+              end
+            end
+          end
+        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
+
+        # Logs the configured application names
+        def app_name_configured?
+          names = Agent.config.app_names
+          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
+          OneApm::Agent.disable_all_tracing { connect(:keep_retrying => false) }
+        end
+
+        # If we're using sinatra, old versions run in an at_exit
+        # block so we should probably know that
+        def using_sinatra?
+          defined?(Sinatra::Application)
+        end
+
+        # we should not set an at_exit block if people are using
+        # these as they don't do standard at_exit behavior per MRI/YARV
+        def weird_ruby?
+          OneApm::LanguageSupport.using_engine?('rbx') ||
+            OneApm::LanguageSupport.using_engine?('jruby') ||
+            using_sinatra?
+        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
+            ::OneApm::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
+            ::OneApm::Agent.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
+        end
+
+        # A correct license key exists and is of the proper length
+        def has_correct_license_key?
+          has_license_key?
+        end
+
+        # 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?
+          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."
+            true
+          else
+            false
+          end
+        end
+
+        def defer_for_background_jobs?
+          if defer_for_delayed_job?
+            ::OneApm::Agent.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"
+            return true
+          end
+
+          false
+        end
+
+        require 'one_apm/inst/background_job/delayed_job_injection'
+
+        def defer_for_delayed_job?
+          OneApm::Agent.config[:dispatcher] == :delayed_job &&
+            !OneApm::DelayedJobInjection.worker_name
+        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?
+          OneApm::Agent.config[:dispatcher] == :resque &&
+            OneApm::LanguageSupport.can_fork? &&
+            !OneApm::Agent::PipeChannelManager.listener.started?
+        end
+
+        def in_resque_child_process?
+          @service.is_a?(OneApm::Agent::PipeService)
+        end
+
+        # Log startup information that we almost always want to know
+        def log_startup
+          log_environment
+          log_dispatcher
+          log_app_name
+        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
+          ::OneApm::Agent.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}"
+        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?
+            ::OneApm::Agent.logger.info 'No known dispatcher detected.'
+          else
+            ::OneApm::Agent.logger.info "Dispatcher: #{dispatcher_name}"
+          end
+        end
+
+        def log_app_name
+          ::OneApm::Agent.logger.info "Application: #{Agent.config.app_names.join(", ")}"
+        end
+
+        def log_ignore_url_regexes
+          regexes = OneApm::Agent.config[:'rules.ignore_url_regexes']
+
+          unless regexes.empty?
+            ::OneApm::Agent.logger.info "Ignoring URLs that match the following regexes: #{regexes.map(&:inspect).join(", ")}."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+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
+        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}"
+            return
+          end
+
+          ::OneApm::Agent.logger.info "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
+              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."
+              end
+            end
+          end
+        end
+
+        def create_and_run_event_loop
+          @event_loop = create_event_loop
+
+          @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.fire_every(Agent.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?
+            @event_loop.on(:report_utilization_data) { transmit_utilization_data }
+
+            @event_loop.fire(:report_utilization_data)
+            @event_loop.fire_every(UTILIZATION_REPORT_PERIOD, :report_utilization_data)
+          end
+
+          @event_loop.run
+        end
+
+        def create_event_loop
+          EventLoop.new
+        end
+
+        def report_period_for(method)
+          config_key = "data_report_periods.#{method}".to_sym
+          period = Agent.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)")
+          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}.")
+            period = MIN_ALLOWED_REPORT_PERIOD
+          end
+          period
+        end
+
+        def stop_event_loop
+          if @event_loop
+            @event_loop.run_once(true) if Agent.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
+          handle_force_restart(e)
+          retry
+        rescue OneApm::ForceDisconnectException => e
+          handle_force_disconnect(e)
+        rescue => e
+          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
+          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})"
+          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)
+          disconnect
+        end
+
+      end
+    end
+  end
+end

data/lib/one_apm/agent/busy_calculator.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'one_apm/transaction/transaction_state'
+
+module OneApm
+  module Agent
+    # This module supports calculation of actual time spent processing requests over the course of
+    # one harvest period.  It's similar to what you would get if you just added up all the
+    # execution times of controller calls, however that will be inaccurate when requests
+    # span the minute boundaries.  This module manages accounting of requests not yet
+    # completed.
+    #
+    # Calls are re-entrant.  All start calls must be paired with finish
+    # calls, or a reset call.
+    module BusyCalculator
+
+      extend self
+
+      # For testability, add accessors:
+      attr_reader :harvest_start, :accumulator
+
+      # sets up busy calculations based on the start and end of
+      # transactions - used for a rough estimate of what percentage of
+      # wall clock time is spent processing requests
+      def dispatcher_start(time) #THREAD_LOCAL_ACCESS
+        state = TransactionState.tl_get
+        state.busy_entries ||= 0
+        callers = state.busy_entries += 1
+        return if callers > 1
+        @lock.synchronize do
+          @entrypoint_stack.push time
+        end
+      end
+
+      # called when a transaction finishes, to add time to the
+      # instance variable accumulator. this is harvested when we send
+      # data to the server
+      def dispatcher_finish(end_time = nil) #THREAD_LOCAL_ACCESS
+        state = TransactionState.tl_get
+        # If #dispatcher_start hasn't been called at least once, abort early
+        return unless state.busy_entries
+
+        end_time ||= time_now
+        callers = state.busy_entries -= 1
+
+        # Ignore nested calls
+        return if callers > 0
+
+        @lock.synchronize do
+          if @entrypoint_stack.empty?
+            ::OneApm::Agent.logger.warn("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")
+          else
+            @accumulator += (end_time - @entrypoint_stack.pop).to_f
+          end
+        end
+      end
+
+      # this returns the size of the entry point stack, which
+      # determines how many transactions are running
+      def busy_count
+        @entrypoint_stack.size
+      end
+
+      # Reset the state of the information accumulated by all threads,
+      # but only reset the recursion counter for this thread.
+      def reset #THREAD_LOCAL_ACCESS
+        @entrypoint_stack = []
+        TransactionState.tl_get.busy_entries = 0
+        @lock ||= Mutex.new
+        @accumulator = 0
+        @harvest_start = time_now
+      end
+
+
+      # Called before uploading to to the server to collect current busy stats.
+      def harvest_busy
+        busy = 0
+        t0 = time_now
+        @lock.synchronize do
+          busy = accumulator
+          @accumulator = 0
+
+          # Walk through the stack and capture all times up to
+          # now for entrypoints
+          @entrypoint_stack.size.times do |frame|
+            busy += (t0 - @entrypoint_stack[frame]).to_f
+            @entrypoint_stack[frame] = t0
+          end
+
+        end
+
+        busy = 0.0 if busy < 0.0 # don't go below 0%
+
+        time_window = (t0 - harvest_start).to_f
+        time_window = 1.0 if time_window == 0.0  # protect against divide by zero
+
+        busy = busy / time_window
+
+        if Agent.config[:report_instance_busy]
+          OneApm::Agent.record_metric('Instance/Busy', busy)
+        end
+        @harvest_start = t0
+      end
+
+      private
+
+      # so we can stub Time.now only for the BusyCalculator in tests
+      def time_now
+        Time.now
+      end
+
+      self.reset
+    end
+  end
+end