scout_apm 3.0.0.pre13 → 3.0.0.pre14

data/lib/scout_apm/agent/exit_handler.rb

@@ -0,0 +1,66 @@
+module ScoutApm
+  class Agent
+    class ExitHandler
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      def install
+        logger.debug "Shutdown handler not supported" and return unless exit_handler_supported?
+        logger.debug "Installing Shutdown Handler"
+
+        at_exit do
+          logger.info "Shutting down Scout Agent"
+          # MRI 1.9 bug drops exit codes.
+          # http://bugs.ruby-lang.org/issues/5218
+          if environment.ruby_19?
+            status = $!.status if $!.is_a?(SystemExit)
+            shutdown
+            exit status if status
+          else
+            shutdown
+          end
+        end
+      end
+
+      private
+
+      # Called via the at_exit handler, it:
+      # (1) Stops the background worker
+      # (2) Stores metrics locally (forcing current-minute metrics to be written)
+      # It does not attempt to actually report metrics.
+      def shutdown
+        logger.info "Shutting down ScoutApm"
+        return if !context.started?
+        context.shutting_down!
+        ScoutApm::Instruments::Stacks.uninstall
+        ::ScoutApm::Agent.instance.stop_background_worker
+      end
+
+      def exit_handler_supported?
+        if environment.sinatra?
+          logger.debug "Exit handler not supported for Sinatra"
+          false
+        elsif environment.jruby?
+          logger.debug "Exit handler not supported for JRuby"
+          false
+        elsif environment.rubinius?
+          logger.debug "Exit handler not supported for Rubinius"
+          false
+        else
+          true
+        end
+      end
+
+      def logger
+        context.logger
+      end
+
+      def environment
+        context.environment
+      end
+    end
+  end
+end

data/lib/scout_apm/agent/preconditions.rb

@@ -0,0 +1,69 @@
+module ScoutApm
+  class Agent
+    class Preconditions
+      # The preconditions here must be a 2 element hash, with :message and :check.
+      # message: Proc that takes the environment, and returns a string
+      # check: Proc that takes an AgentContext and returns true if precondition was met, if false, we shouldn't start.
+      PRECONDITIONS = [
+        PRECONDITION_ENABLED = {
+          :message => proc {|environ| "Monitoring isn't enabled for the [#{environ.env}] environment." },
+          :check => proc { |context| context.config.value('monitor') },
+        },
+
+        PRECONDITION_APP_NAME = {
+          :message => proc {|environ| "An application name could not be determined. Specify the :name value in scout_apm.yml." },
+          :check => proc { |context| context.environment.application_name },
+        },
+
+        PRECONDITION_INTERACTIVE = {
+          :message => proc {|environ| "Agent attempting to load in interactive mode." },
+          :check => proc { |context| ! context.environment.interactive? },
+        },
+
+        PRECONDITION_DETECTED_SERVER = {
+          :message => proc {|environ| "Deferring agent start. Standing by for first request" },
+          :check => proc { |context| !app_server_missing?(context) && !background_job_missing?(context) },
+        },
+
+        PRECONDITION_ALREADY_STARTED = {
+          :message => proc {|environ| "Already started agent." },
+          :check => proc { |context| !context.started? },
+        },
+
+        PRECONDITION_OLD_SCOUT_RAILS = {
+          :message => proc {|environ| "ScoutAPM is incompatible with the old Scout Rails plugin. Please remove scout_rails from your Gemfile" },
+          :check => proc { !defined?(::ScoutRails) },
+        },
+      ]
+
+      def self.check?(context)
+        failed_preconditions = PRECONDITIONS.inject(Array.new) { |errors, condition|
+          met = condition[:check].call(context)
+          errors << condition[:message].call(context.environment) unless met
+          errors
+        }
+
+        if failed_preconditions.any?
+          failed_preconditions.each {|msg| context.logger.warn(msg) }
+          force? # if forced, return true anyway
+        else
+          # No errors, we met preconditions
+          true
+        end
+      end
+
+      # XXX: Wire up options here and below in the appserver & bg server detections
+      def self.force?
+        false
+      end
+
+      def self.app_server_missing?(context)
+        !context.environment.app_server_integration(true).found? # && !options[:skip_app_server_check]
+      end
+
+      def self.background_job_missing?(context)
+        context.environment.background_job_integrations.length == 0
+      end
+    end
+  end
+end

data/lib/scout_apm/agent_context.rb

@@ -0,0 +1,234 @@
+module ScoutApm
+  class AgentContext
+    # Initially start up without attempting to load a configuration file. We
+    # need to be able to lookup configuration options like "application_root"
+    # which would then in turn influence where the yaml configuration file is
+    # located
+    #
+    # Later in initialization, we set config= to include the file.
+    def initialize()
+      @logger = LoggerFactory.build_minimal_logger
+      @process_start_time = Time.now
+    end
+
+    def marshal_dump
+      []
+    end
+
+    def marshal_load(*args)
+      @logger = LoggerFactory.build_minimal_logger
+      @process_start_time = Time.now
+    end
+
+    #####################################
+    #  Lifecycle: Remote Server/Client
+    #
+    #  This allows short lived forked processes to communicate back to the parent process.
+    #  Used in the Resque instrumentation
+    #
+    #  Parent Pre-fork: start_remote_server! once
+    #  Child Post-fork: become_remote_client! after each fork
+    #
+    #  TODO: Figure out where to extract this to
+    #####################################
+
+    def start_remote_server!(bind, port)
+      return if @remote_server && @remote_server.running?
+
+      logger.info("Starting Remote Agent Server")
+
+      # Start the listening web server only in parent process.
+      @remote_server = ScoutApm::Remote::Server.new(
+        bind,
+        port,
+        ScoutApm::Remote::Router.new(ScoutApm::SynchronousRecorder.new(logger), logger),
+        logger
+      )
+
+      @remote_server.start
+    end
+
+    # Execute this in the child process of a remote agent. The parent is
+    # expected to have its accepting webserver up and running
+    def become_remote_client!(host, port)
+      logger.debug("Becoming Remote Agent (reporting to: #{host}:#{port})")
+      recorder = ScoutApm::Remote::Recorder.new(host, port, logger)
+      store = ScoutApm::FakeStore.new
+    end
+
+
+    ###############
+    #  Accessors  #
+    ###############
+
+    attr_reader :process_start_time
+
+    def config
+      @config ||= ScoutApm::Config.without_file(self)
+    end
+
+    def environment
+      @environment ||= ScoutApm::Environment.instance
+    end
+
+    def started?
+      @started
+    end
+
+    def shutting_down?
+      @shutting_down
+    end
+
+    def installed?
+      @installed
+    end
+
+    def logger
+      @logger ||= LoggerFactory.build(config, environment)
+    end
+
+    def ignored_uris
+      @ignored_uris ||= ScoutApm::IgnoredUris.new(config.value('ignore'))
+    end
+
+    def slow_request_policy
+      @slow_request_policy ||= ScoutApm::SlowRequestPolicy.new(self)
+    end
+
+    def slow_job_policy
+      @slow_job_policy ||= ScoutApm::SlowJobPolicy.new(self)
+    end
+
+    # Histogram of the cumulative requests since the start of the process
+    def request_histograms
+      @request_histograms ||= ScoutApm::RequestHistograms.new
+    end
+
+    # Histogram of the requests, distinct by reporting period (minute)
+    # { StoreReportingPeriodTimestamp => RequestHistograms }
+    def request_histograms_by_time
+      @request_histograms_by_time ||= Hash.new { |h, k| h[k] = ScoutApm::RequestHistograms.new }
+    end
+
+    def store
+      return @store if @store
+      self.store = ScoutApm::Store.new(self)
+    end
+
+    def layaway
+      @layaway ||= ScoutApm::Layaway.new(self)
+    end
+
+    def recorder
+      @recorder ||= RecorderFactory.build(self)
+    end
+
+    def dev_trace_enabled?
+      config.value('dev_trace') && environment.env == "development"
+    end
+
+    #############
+    #  Setters  #
+    #############
+
+    # When we set the config for any reason, there are some values we must
+    # reinitialize, since the config could have changed their settings, so nil
+    # them out here, then let them get lazily reset as needed
+    #
+    # Don't use this in initializer, since it'll attempt to log immediately
+    def config=(config)
+      @config = config
+
+      @logger = nil
+
+      log_configuration_settings
+
+      @ignored_uris = nil
+      @slow_request_policy = nil
+      @slow_job_policy = nil
+      @request_histograms = nil
+      @request_histograms_by_time = nil
+      @store = nil
+      @layaway = nil
+      @recorder = nil
+    end
+
+    def installed!
+      @installed = true
+    end
+
+    def started!
+      @started = true
+    end
+
+    def shutting_down!
+      @shutting_down = true
+    end
+
+    def store=(store)
+      @store = store
+
+      # Installs the default samplers
+      # Don't install samplers on nil stores
+      if store
+        ScoutApm::Instruments::Samplers::DEFAULT_SAMPLERS.each { |s| store.add_sampler(s) }
+      end
+    end
+
+    def recorder=(recorder)
+      @recorder = recorder
+    end
+
+    # I believe this is only useful for testing?
+    def environment=(env)
+      @environment = env
+    end
+
+    #########################
+    #  Callbacks & helpers  #
+    #
+    #  Should find ways to remove these into external spots
+    #########################
+
+    # Called after config is reset and loaded from file
+    def log_configuration_settings
+      @config.log_settings(logger)
+
+      if !@config.any_keys_found?
+        logger.info("No configuration file loaded, and no configuration found in ENV. " +
+                    "For assistance configuring Scout, visit " +
+                    "http://help.apm.scoutapp.com/#configuration-options")
+      end
+    end
+  end
+
+  class RecorderFactory
+    def self.build(context)
+      if context.config.value("async_recording")
+        context.logger.debug("Using asynchronous recording")
+        ScoutApm::BackgroundRecorder.new(context).start
+      else
+        context.logger.debug("Using synchronous recording")
+        ScoutApm::SynchronousRecorder.new(context).start
+      end
+    end
+  end
+
+  class LoggerFactory
+    def self.build(config, environment)
+      ScoutApm::Logger.new(environment.root,
+        {
+          :log_level     => config.value('log_level'),
+          :log_file_path => config.value('log_file_path'),
+          :stdout        => config.value('log_stdout'),
+          :stderr        => config.value('log_stderr'),
+          :logger_class  => config.value('log_class'),
+        }
+      )
+    end
+
+    def self.build_minimal_logger
+      ScoutApm::Logger.new(nil, :stdout => true)
+    end
+  end
+end

data/lib/scout_apm/app_server_load.rb

@@ -1,9 +1,11 @@
 module ScoutApm
   class AppServerLoad
     attr_reader :logger
+    attr_reader :context
 
-    def initialize(logger=Agent.instance.logger)
-      @logger = logger
+    def initialize(context)
+      @context = context
+      @logger = context.logger
     end
 
     def run
@@ -13,7 +15,7 @@ module ScoutApm
           logger.debug("Full Application Startup Info: #{data.inspect}")
 
           payload = ScoutApm::Serializers::AppServerLoadSerializer.serialize(data)
-          reporter = Reporter.new(:app_server_load)
+          reporter = Reporter.new(context, :app_server_load)
           reporter.report(payload)
 
           logger.debug("Finished sending Startup Info")
@@ -28,19 +30,23 @@ module ScoutApm
 
     def data
       { :server_time        => to_s_safe(Time.now),
-        :framework          => to_s_safe(ScoutApm::Environment.instance.framework_integration.human_name),
-        :framework_version  => to_s_safe(ScoutApm::Environment.instance.framework_integration.version),
-        :environment        => to_s_safe(ScoutApm::Environment.instance.framework_integration.env),
-        :app_server         => to_s_safe(ScoutApm::Environment.instance.app_server),
+        :framework          => to_s_safe(environment.framework_integration.human_name),
+        :framework_version  => to_s_safe(environment.framework_integration.version),
+        :environment        => to_s_safe(environment.framework_integration.env),
+        :app_server         => to_s_safe(environment.app_server),
         :ruby_version       => RUBY_VERSION,
-        :hostname           => to_s_safe(ScoutApm::Environment.instance.hostname),
-        :database_engine    => to_s_safe(ScoutApm::Environment.instance.database_engine),      # Detected
-        :database_adapter   => to_s_safe(ScoutApm::Environment.instance.raw_database_adapter), # Raw
-        :application_name   => to_s_safe(ScoutApm::Environment.instance.application_name),
-        :libraries          => ScoutApm::Utils::InstalledGems.new.run,
-        :paas               => to_s_safe(ScoutApm::Environment.instance.platform_integration.name),
-        :git_sha            => to_s_safe(ScoutApm::Environment.instance.git_revision.sha)
+        :hostname           => to_s_safe(environment.hostname),
+        :database_engine    => to_s_safe(environment.database_engine),      # Detected
+        :database_adapter   => to_s_safe(environment.raw_database_adapter), # Raw
+        :application_name   => to_s_safe(environment.application_name),
+        :libraries          => ScoutApm::Utils::InstalledGems.new(context).run,
+        :paas               => to_s_safe(environment.platform_integration.name),
+        :git_sha            => to_s_safe(environment.git_revision.sha)
       }
+    ensure
+      # Sometimes :database_engine and :database_adapter can cause a reference to an AR connection.
+      # Make sure we release all AR connections held by this thread.
+      ActiveRecord::Base.clear_active_connections! if Utils::KlassHelper.defined?("ActiveRecord::Base")
     end
 
     # Calls `.to_s` on the object passed in.
@@ -52,5 +58,9 @@ module ScoutApm
         'to_s error'
       end
     end
+
+    def environment
+      context.environment
+    end
   end
 end

data/lib/scout_apm/background_job_integrations/resque.rb

@@ -26,13 +26,12 @@ module ScoutApm
       def install_before_fork
         ::Resque.before_first_fork do
           begin
-            ScoutApm::Agent.instance.start(:skip_app_server_check => true)
-            ScoutApm::Agent.instance.start_background_worker
-            ScoutApm::Agent.instance.start_remote_server(bind, port)
+            ScoutApm::Agent.instance.start
+            ScoutApm::Agent.instance.context.start_remote_server!(bind, port)
           rescue Errno::EADDRINUSE
-            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque Instruments, Port #{port} already in use. Set via the `remote_agent_port` configuration option"
+            ScoutApm::Agent.instance.context.logger.warn "Error while Installing Resque Instruments, Port #{port} already in use. Set via the `remote_agent_port` configuration option"
           rescue => e
-            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque before_first_fork: #{e.inspect}"
+            ScoutApm::Agent.instance.context.logger.warn "Error while Installing Resque before_first_fork: #{e.inspect}"
           end
         end
       end
@@ -40,10 +39,10 @@ module ScoutApm
       def install_after_fork
         ::Resque.after_fork do
           begin
-            ScoutApm::Agent.instance.use_remote_recorder(bind, port)
+            ScoutApm::Agent.instance.context.become_remote_client!(bind, port)
             inject_job_instrument
           rescue => e
-            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque after_fork: #{e.inspect}"
+            ScoutApm::Agent.instance.context.logger.warn "Error while Installing Resque after_fork: #{e.inspect}"
           end
         end
       end
@@ -77,7 +76,7 @@ module ScoutApm
       end
 
       def config
-        @config || ScoutApm::Agent.instance.config
+        @config || ScoutApm::Agent.instance.context.config
       end
     end
   end