scout_apm 2.2.0.pre3 → 2.3.0.pre

data/lib/scout_apm/background_job_integrations/resque.rb

@@ -0,0 +1,85 @@
+module ScoutApm
+  module BackgroundJobIntegrations
+    class Resque
+      def name
+        :resque
+      end
+
+      def present?
+        defined?(::Resque) &&
+          ::Resque.respond_to?(:before_first_fork) &&
+          ::Resque.respond_to?(:after_fork)
+      end
+
+      # Lies. This forks really aggressively, but we have to do handling
+      # of it manually here, rather than via any sort of automatic
+      # background worker starting
+      def forking?
+        false
+      end
+
+      def install
+        install_before_fork
+        install_after_fork
+      end
+
+      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)
+          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"
+          rescue => e
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque before_first_fork: #{e.inspect}"
+          end
+        end
+      end
+
+      def install_after_fork
+        ::Resque.after_fork do
+          begin
+            ScoutApm::Agent.instance.use_remote_recorder(bind, port)
+            inject_job_instrument
+          rescue => e
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque after_fork: #{e.inspect}"
+          end
+        end
+      end
+
+      # Insert ourselves into the point when resque turns a string "TestJob"
+      # into the class constant TestJob, and insert our instrumentation plugin
+      # into that constantized class
+      #
+      # This automates away any need for the user to insert our instrumentation into
+      # each of their jobs
+      def inject_job_instrument
+        ::Resque::Job.class_eval do
+          def payload_class_with_scout_instruments
+            klass = payload_class_without_scout_instruments
+            klass.extend(ScoutApm::Instruments::Resque)
+            klass
+          end
+          alias_method :payload_class_without_scout_instruments, :payload_class
+          alias_method :payload_class, :payload_class_with_scout_instruments
+        end
+      end
+
+      private
+
+      def bind
+        config.value("remote_agent_host")
+      end
+
+      def port
+        config.value("remote_agent_port")
+      end
+
+      def config
+        @config || ScoutApm::Agent.instance.config
+      end
+    end
+  end
+end
+

data/lib/scout_apm/background_job_integrations/sidekiq.rb

@@ -55,27 +55,15 @@ module ScoutApm
     # We insert this middleware into the Sidekiq stack, to capture each job,
     # and time them.
     class SidekiqMiddleware
-      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper'.freeze
-
       def call(_worker, msg, queue)
         req = ScoutApm::RequestManager.lookup
         req.job!
         req.annotate_request(:queue_latency => latency(msg))
 
-        queue_layer = ScoutApm::Layer.new('Queue', queue)
-        job_layer = ScoutApm::Layer.new('Job', job_class(msg))
-
-        if ScoutApm::Agent.instance.config.value('profile') && SidekiqMiddleware.version_supports_profiling?
-          # Capture ScoutProf if we can
-          #req.enable_profiled_thread!
-          #job_layer.set_root_class(job_class)
-          #job_layer.traced!
-        end
-
         begin
-          req.start_layer(queue_layer)
+          req.start_layer(ScoutApm::Layer.new('Queue', queue))
           started_queue = true
-          req.start_layer(job_layer)
+          req.start_layer(ScoutApm::Layer.new('Job', job_class(msg)))
           started_job = true
 
           yield
@@ -89,12 +77,30 @@ module ScoutApm
       end
 
       UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
+      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper'.freeze
+      DELAYED_WRAPPER_KLASS = 'Sidekiq::Extensions::DelayedClass'.freeze
+
 
       def job_class(msg)
         job_class = msg.fetch('class', UNKNOWN_CLASS_PLACEHOLDER)
+
         if job_class == ACTIVE_JOB_KLASS && msg.key?('wrapped')
-          job_class = msg['wrapped']
+          begin
+            job_class = msg['wrapped']
+          rescue
+            ACTIVE_JOB_KLASS
+          end
+        elsif job_class == DELAYED_WRAPPER_KLASS
+          begin
+            yml = msg['args'].first
+            deserialized_args = YAML.load(yml)
+            klass, method, *rest = deserialized_args
+            job_class = [klass,method].map(&:to_s).join(".")
+          rescue
+            DELAYED_WRAPPER_KLASS
+          end
         end
+
         job_class
       rescue
         UNKNOWN_CLASS_PLACEHOLDER
@@ -110,10 +116,6 @@ module ScoutApm
       rescue
         0
       end
-
-      def self.version_supports_profiling?
-        @@sidekiq_supports_profling ||= defined?(::Sidekiq::VERSION) && Gem::Dependency.new('', '~> 4.0').match?('', ::Sidekiq::VERSION.to_s)
-      end
-    end # SidekiqMiddleware
+    end
   end
 end

data/lib/scout_apm/background_recorder.rb

@@ -0,0 +1,43 @@
+# Provide a background thread queue to do the processing of
+# TrackedRequest objects, to remove it from the hot-path of returning a
+# web response
+
+module ScoutApm
+  class BackgroundRecorder
+    attr_reader :queue
+    attr_reader :thread
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+      @queue = Queue.new
+    end
+
+    def start
+      logger.info("Starting BackgroundRecorder")
+      @thread = Thread.new(&method(:thread_func))
+      self
+    end
+
+    def stop
+      @thread.kill
+    end
+
+    def record!(request)
+      start unless @thread.alive?
+      @queue.push(request)
+    end
+
+    def thread_func
+      while req = queue.pop
+        begin
+          logger.debug("recording in thread. Queue size: #{queue.size}")
+          # For now, just proxy right back into the TrackedRequest object's record function
+          req.record!
+        rescue => e
+          logger.warn("Error in BackgroundRecorder - #{e.message} : #{e.backtrace}")
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/background_worker.rb

@@ -11,6 +11,10 @@ module ScoutApm
       @keep_running = true
     end
 
+    def running?
+      @keep_running
+    end
+
     def stop
       ScoutApm::Agent.instance.logger.debug "Background Worker: stop requested"
       @keep_running = false
@@ -25,19 +29,13 @@ module ScoutApm
     def start(&block)
       @task = block
 
-      begin
-        ScoutApm::Agent.instance.logger.debug "Background Worker: Starting Background Worker, running every #{period} seconds"
+      ScoutApm::Agent.instance.logger.debug "Background Worker: Starting Background Worker, running every #{period} seconds"
 
-        # The first run should be 1 period of time from now
-        next_time = Time.now + period
-
-        loop do
-          # Bail out if @keep_running is false
-          unless @keep_running
-            ScoutApm::Agent.instance.logger.debug "Background Worker: breaking from loop"
-            break
-          end
+      # The first run should be 1 period of time from now
+      next_time = Time.now + period
 
+      loop do
+        begin
           now = Time.now
 
           # Sleep the correct amount of time to reach next_time
@@ -47,17 +45,23 @@ module ScoutApm
             now = Time.now
           end
 
+          # Bail out if @keep_running is false
+          unless @keep_running
+            ScoutApm::Agent.instance.logger.debug "Background Worker: breaking from loop"
+            break
+          end
+
           @task.call
 
           # Adjust the next time to run forward by @periods until it is in the future
           while next_time <= now
             next_time += period
           end
+        rescue
+          ScoutApm::Agent.instance.logger.debug "Background Worker Exception!"
+          ScoutApm::Agent.instance.logger.debug $!.message
+          ScoutApm::Agent.instance.logger.debug $!.backtrace
         end
-      rescue
-        ScoutApm::Agent.instance.logger.debug "Background Worker Exception!"
-        ScoutApm::Agent.instance.logger.debug $!.message
-        ScoutApm::Agent.instance.logger.debug $!.backtrace
       end
     end
   end

data/lib/scout_apm/config.rb

@@ -5,30 +5,63 @@ require 'scout_apm/environment'
 
 # Valid Config Options:
 #
+# This list is complete, but some are old and unused, or for developers of
+# scout_apm itself. See the documentation at http://help.apm.scoutapp.com for
+# customer-focused documentation.
+#
 # application_root - override the detected directory of the application
+# compress_payload - true/false to enable gzipping of payload
 # data_file        - override the default temporary storage location. Must be a location in a writable directory
-# host             - override the default hostname detection. Default varies by environment - either system hostname, or PAAS hostname
+# dev_trace        - true or false. Enables always-on tracing in development environmen only
 # direct_host      - override the default "direct" host. The direct_host bypasses the ingestion pipeline and goes directly to the webserver, and is primarily used for features under development.
+# enable_background_jobs - true or false
+# host             - configuration used in development
+# hostname         - override the default hostname detection. Default varies by environment - either system hostname, or PAAS hostname
 # key              - the account key with Scout APM. Found in Settings in the Web UI
 # log_file_path    - either a directory or "STDOUT".
 # log_level        - DEBUG / INFO / WARN as usual
 # monitor          - true or false.  False prevents any instrumentation from starting
 # name             - override the name reported to APM. This is the name that shows in the Web UI
-# uri_reporting    - 'path' or 'full_path' default is 'full_path', which reports URL params as well as the path.
+# profile          - turn on/off scoutprof (only applicable in Gem versions including scoutprof)
+# proxy            - an http proxy
 # report_format    - 'json' or 'marshal'. Marshal is legacy and will be removed.
-# dev_trace        - true or false. Enables always-on tracing in development environmen only
-# enable_background_jobs - true or false
+# scm_subdirectory - if the app root lives in source management in a subdirectory. E.g. #{SCM_ROOT}/src
+# uri_reporting    - 'path' or 'full_path' default is 'full_path', which reports URL params as well as the path.
+# remote_agent_host - Internal: What host to bind to, and also send messages to for remote. Default: 127.0.0.1.
+# remote_agent_port - What port to bind the remote webserver to
 #
 # Any of these config settings can be set with an environment variable prefixed
 # by SCOUT_ and uppercasing the key: SCOUT_LOG_LEVEL for instance.
 
-
-# Config - Made up of config overlay
-# Default -> File -> Environment Var
-# QUESTION: How to embed arrays or hashes into ENV?
-
 module ScoutApm
   class Config
+    KNOWN_CONFIG_OPTIONS = [
+        'application_root',
+        'async_recording',
+        'compress_payload',
+        'config_file',
+        'data_file',
+        'detailed_middleware',
+        'dev_trace',
+        'direct_host',
+        'disabled_instruments',
+        'enable_background_jobs',
+        'host',
+        'hostname',
+        'ignore',
+        'key',
+        'log_file_path',
+        'log_level',
+        'monitor',
+        'name',
+        'profile',
+        'proxy',
+        'remote_agent_host',
+        'remote_agent_port',
+        'report_format',
+        'scm_subdirectory',
+        'uri_reporting',
+    ]
 
     ################################################################################
     # Coersions
@@ -92,6 +125,12 @@ module ScoutApm
       end
     end
 
+    class IntegerCoercion
+      def coerce(val)
+        val.to_i
+      end
+    end
+
     # Simply returns the passed in value, without change
     class NullCoercion
       def coerce(val)
@@ -101,10 +140,14 @@ module ScoutApm
 
 
     SETTING_COERCIONS = {
-      "monitor"                => BooleanCoercion.new,
-      "enable_background_jobs" => BooleanCoercion.new,
+      "async_recording"        => BooleanCoercion.new,
+      "detailed_middleware"    => BooleanCoercion.new,
       "dev_trace"              => BooleanCoercion.new,
+      "enable_background_jobs" => BooleanCoercion.new,
       "ignore"                 => JsonCoercion.new,
+      "monitor"                => BooleanCoercion.new,
+      'database_metric_limit'  => IntegerCoercion.new,
+      'database_metric_report_limit' => IntegerCoercion.new,
     }
 
 
@@ -129,7 +172,7 @@ module ScoutApm
     def self.with_file(file_path=nil, config={})
       overlays = [
         ConfigEnvironment.new,
-        ConfigFile.new(file_path, config[:file]),
+        ConfigFile.new(file_path, config),
         ConfigDefaults.new,
         ConfigNull.new,
       ]
@@ -140,8 +183,17 @@ module ScoutApm
       @overlays = Array(overlays)
     end
 
+    # For a given key, what is the first overlay says that it can handle it?
+    def overlay_for_key(key)
+      @overlays.detect{ |overlay| overlay.has_key?(key) }
+    end
+
     def value(key)
-      o = @overlays.detect{ |overlay| overlay.has_key?(key) }
+      if ! KNOWN_CONFIG_OPTIONS.include?(key)
+        ScoutApm::Agent.instance.logger.debug("Requested looking up a unknown configuration key: #{key} (not a problem. Evaluate and add to config.rb)")
+      end
+
+      o = overlay_for_key(key)
       raw_value = if o
                     o.value(key)
                   else
@@ -149,22 +201,42 @@ module ScoutApm
                     nil
                   end
 
-      coercion = SETTING_COERCIONS[key] || NullCoercion.new
+      coercion = SETTING_COERCIONS.fetch(key, NullCoercion.new)
       coercion.coerce(raw_value)
     end
 
+    # Did we load anything for configuration?
+    def any_keys_found?
+      @overlays.any? { |overlay| overlay.any_keys_found? }
+    end
+
+    def log_settings
+      messages = KNOWN_CONFIG_OPTIONS.inject([]) do |memo, key|
+        o = overlay_for_key(key)
+        memo << "#{o.name} - #{key}: #{value(key).inspect}"
+      end
+      ScoutApm::Agent.instance.logger.debug("Resolved Setting Values:\n" + messages.join("\n"))
+    end
+
     class ConfigDefaults
       DEFAULTS = {
-        'host'                   => 'https://checkin.scoutapp.com',
+        'compress_payload'       => true,
+        'detailed_middleware'    => false,
+        'dev_trace'              => false,
         'direct_host'            => 'https://apm.scoutapp.com',
-        'log_level'              => 'info',
-        'uri_reporting'          => 'full_path',
-        'report_format'          => 'json',
         'disabled_instruments'   => [],
         'enable_background_jobs' => true,
+        'host'                   => 'https://checkin.scoutapp.com',
         'ignore'                 => [],
-        'dev_trace' => false, # false for now so code can live in main branch
-        'profile' => true # for scoutprof
+        'log_level'              => 'info',
+        'profile'                => true, # for scoutprof
+        'report_format'          => 'json',
+        'scm_subdirectory'       => '',
+        'uri_reporting'          => 'full_path',
+        'remote_agent_host'      => '127.0.0.1',
+        'remote_agent_port'      => 7721, # picked at random
+        'database_metric_limit'  => 5000, # The hard limit on db metrics
+        'database_metric_report_limit' => 1000,
       }.freeze
 
       def value(key)
@@ -174,6 +246,15 @@ module ScoutApm
       def has_key?(key)
         DEFAULTS.has_key?(key)
       end
+
+      # Defaults are here, but not counted as user specified.
+      def any_keys_found?
+        false
+      end
+
+      def name
+        "defaults"
+      end
     end
 
 
@@ -188,6 +269,14 @@ module ScoutApm
       def has_key?(*)
         true
       end
+
+      def any_keys_found?
+        false
+      end
+
+      def name
+        "no-config"
+      end
     end
 
     class ConfigEnvironment
@@ -203,6 +292,16 @@ module ScoutApm
       def key_to_env_key(key)
         'SCOUT_' + key.upcase
       end
+
+      def any_keys_found?
+        KNOWN_CONFIG_OPTIONS.any? { |option|
+          ENV.has_key?(key_to_env_key(option))
+        }
+      end
+
+      def name
+        "environment"
+      end
     end
 
     # Attempts to load a configuration file, and parse it as YAML. If the file
@@ -228,6 +327,16 @@ module ScoutApm
         @settings.has_key?(key)
       end
 
+      def any_keys_found?
+        KNOWN_CONFIG_OPTIONS.any? { |option|
+          @settings.has_key?(option)
+        }
+      end
+
+      def name
+        "config-file"
+      end
+
       private
 
       def load_file(file)
@@ -248,17 +357,18 @@ module ScoutApm
           raw_file = File.read(@resolved_file_path)
           erb_file = ERB.new(raw_file).result(binding)
           parsed_yaml = YAML.load(erb_file)
-          @settings = parsed_yaml[app_environment]
+          file_settings = parsed_yaml[app_environment]
 
-          if !@settings.is_a? Hash
-            raise ("Missing environment key for: #{app_environment}. This can happen if the key is missing, or with a malformed configuration file," +
-                   " check that there is a top level #{app_environment} key.")
+          if file_settings.is_a? Hash
+            logger.debug("Loaded Configuration: #{@resolved_file_path}. Using environment: #{app_environment}")
+            @settings = file_settings
+            @file_loaded = true
+          else
+            logger.info("Couldn't find configuration in #{@resolved_file_path} for environment: #{app_environment}. Configuration in ENV will still be applied.")
+            @file_loaded = false
           end
-
-          logger.debug("Loaded Configuration: #{@resolved_file_path}. Using environment: #{app_environment}")
-          @file_loaded = true
         rescue Exception => e # Explicit `Exception` handling to catch SyntaxError and anything else that ERB or YAML may throw
-          logger.debug("Failed loading configuration file: #{e.message}. ScoutAPM will continue starting with configuration from ENV and defaults")
+          logger.info("Failed loading configuration file (#{@resolved_file_path}): #{e.message}. ScoutAPM will continue starting with configuration from ENV and defaults")
           @file_loaded = false
         end
       end