scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/background_job_integrations/delayed_job.rb

@@ -1,9 +1,6 @@
 module ScoutApm
   module BackgroundJobIntegrations
     class DelayedJob
-      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper'.freeze
-      DJ_PERFORMABLE_METHOD = 'Delayed::PerformableMethod'.freeze
-
       attr_reader :logger
 
       def name
@@ -11,78 +8,12 @@ module ScoutApm
       end
 
       def present?
-        defined?(::Delayed::Job)
+        defined?(::Delayed::Job) && (File.basename($0) =~ /\Adelayed_job/)
       end
 
       def forking?
         false
       end
-
-      def install
-        plugin = Class.new(Delayed::Plugin) do
-          require 'delayed_job'
-
-          callbacks do |lifecycle|
-            lifecycle.around(:invoke_job) do |job, *args, &block|
-              ScoutApm::Agent.instance.start_background_worker unless ScoutApm::Agent.instance.background_worker_running?
-
-              name = begin
-                       case job.payload_object.class.to_s
-
-                       # ActiveJob's class wraps the actual job class
-                       when ACTIVE_JOB_KLASS
-                         job.payload_object.job_data["job_class"]
-
-                       # An adhoc job, called like `@user.delay.fib(10)`.
-                       # returns a string like "User#fib"
-                       when DJ_PERFORMABLE_METHOD
-                         job.name
-
-                       # A "real" job called like `Delayed::Job.enqueue(MyJob.new)`
-                       # returns "MyJob"
-                       else
-                         job.payload_object.class.to_s
-                       end
-                     rescue
-                       # Fall back to whatever DJ thinks the name is.
-                       job.name
-                     end
-
-              queue = job.queue || "default"
-
-              req = ScoutApm::RequestManager.lookup
-
-              begin
-                latency = Time.now - [job.created_at, job.run_at].max
-                req.annotate_request(:queue_latency => latency)
-              rescue
-              end
-
-              queue_layer = ScoutApm::Layer.new('Queue', queue)
-              job_layer = ScoutApm::Layer.new('Job', name)
-
-              begin
-                req.start_layer(queue_layer)
-                started_queue = true
-                req.start_layer(job_layer)
-                started_job = true
-
-                # Call the job itself.
-                block.call(job, *args)
-              rescue
-                req.error!
-                raise
-              ensure
-                req.stop_layer if started_job
-                req.stop_layer if started_queue
-              end
-            end
-          end
-        end
-
-        Delayed::Worker.plugins << plugin # ScoutApm::BackgroundJobIntegrations::DelayedJobPlugin
-      end
     end
   end
 end
-

data/lib/scout_apm/background_job_integrations/sidekiq.rb

@@ -40,10 +40,10 @@ module ScoutApm
         require 'sidekiq/processor' # sidekiq v4 has not loaded this file by this point
 
         ::Sidekiq::Processor.class_eval do
-          def initialize_with_scout(*args)
+          def initialize_with_scout(boss)
             agent = ::ScoutApm::Agent.instance
-            agent.start
-            initialize_without_scout(*args)
+            agent.start_background_worker
+            initialize_without_scout(boss)
           end
 
           alias_method :initialize_without_scout, :initialize
@@ -55,14 +55,27 @@ 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(ScoutApm::Layer.new('Queue', queue))
+          req.start_layer(queue_layer)
           started_queue = true
-          req.start_layer(ScoutApm::Layer.new('Job', job_class(msg)))
+          req.start_layer(job_layer)
           started_job = true
 
           yield
@@ -76,36 +89,12 @@ 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')
-          begin
-            job_class = msg['wrapped']
-          rescue
-            ACTIVE_JOB_KLASS
-          end
-        elsif job_class == DELAYED_WRAPPER_KLASS
-          begin
-            # Extract the info out of the wrapper
-            yml = msg['args'].first
-            deserialized_args = YAML.load(yml)
-            klass, method, *rest = deserialized_args
-
-            # If this is an instance of a class, get the class itself
-            # Prevents instances from coming through named like "#<Foo:0x007ffd7a9dd8a0>"
-            klass = klass.class unless klass.is_a? Module
-
-            job_class = [klass, method].map(&:to_s).join(".")
-          rescue
-            DELAYED_WRAPPER_KLASS
-          end
+          job_class = msg['wrapped']
         end
-
         job_class
       rescue
         UNKNOWN_CLASS_PLACEHOLDER
@@ -121,6 +110,10 @@ module ScoutApm
       rescue
         0
       end
-    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

data/lib/scout_apm/background_worker.rb

@@ -6,24 +6,13 @@ module ScoutApm
 
     attr_reader :period
 
-    attr_reader :context
-
-    def initialize(context, period=DEFAULT_PERIOD)
-      @context = context
+    def initialize(period=DEFAULT_PERIOD)
       @period = period
       @keep_running = true
     end
 
-    def logger
-      context.logger
-    end
-
-    def running?
-      @keep_running
-    end
-
     def stop
-      logger.debug "Background Worker: stop requested"
+      ScoutApm::Agent.instance.logger.debug "Background Worker: stop requested"
       @keep_running = false
     end
 
@@ -36,13 +25,19 @@ module ScoutApm
     def start(&block)
       @task = block
 
-      logger.debug "Background Worker: starting to run 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
         begin
+          # Bail out if @keep_running is false
+          unless @keep_running
+            ScoutApm::Agent.instance.logger.debug "Background Worker: breaking from loop"
+            break
+          end
+
           now = Time.now
 
           # Sleep the correct amount of time to reach next_time
@@ -52,12 +47,6 @@ module ScoutApm
             now = Time.now
           end
 
-          # Bail out if @keep_running is false
-          unless @keep_running
-            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
@@ -65,9 +54,9 @@ module ScoutApm
             next_time += period
           end
         rescue
-          logger.debug "Background Worker Exception!"
-          logger.debug $!.message
-          logger.debug $!.backtrace
+          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/capacity.rb

@@ -0,0 +1,57 @@
+# Encapsulates logic for determining capacity utilization of the Ruby processes.
+module ScoutApm
+  class Capacity
+    attr_reader :processing_start_time, :accumulated_time, :transaction_entry_time
+
+    def initialize
+      @processing_start_time = Time.now
+      @lock ||= Mutex.new # the transaction_entry_time could be modified while processing a request or when #process is called.
+      @accumulated_time = 0.0
+    end
+
+    # Called when a transaction is traced.
+    def start_transaction!
+      @lock.synchronize do
+        @transaction_entry_time = Time.now
+      end
+    end
+
+    # Called when a transaction completes to record its time used.
+    def finish_transaction!
+      @lock.synchronize do
+        if transaction_entry_time
+          @accumulated_time += (Time.now - transaction_entry_time).to_f
+        else
+          ScoutApm::Agent.instance.logger.warn "No transaction entry time. Not recording capacity metrics for transaction."
+        end
+        @transaction_entry_time = nil
+      end
+    end
+
+    # Ran when sending metrics to server. Reports capacity usage metrics.
+    def process
+      process_time = Time.now
+      ScoutApm::Agent.instance.logger.debug "Processing capacity usage for [#{@processing_start_time}] to [#{process_time}]. Time Spent: #{@accumulated_time}."
+      @lock.synchronize do
+        time_spent = @accumulated_time
+        @accumulated_time = 0.0
+        # If a transaction is still running, capture its running time up to now and
+        # reset the +transaction_entry_time+ to now.
+        if @transaction_entry_time
+          time_spent += (process_time - @transaction_entry_time).to_f
+          ScoutApm::Agent.instance.logger.debug "A transaction is running while calculating capacity. Start time: [#{transaction_entry_time}]. Will update the entry time to [#{process_time}]."
+          @transaction_entry_time = process_time # prevent from over-counting capacity usage. update the transaction start time to now.
+        end
+        time_spent = 0.0 if time_spent < 0.0
+
+        window = (process_time - processing_start_time).to_f # time period we are evaulating capacity usage.
+        window = 1.0 if window <= 0.0 # prevent divide-by-zero if clock adjusted.
+        capacity = time_spent / window
+        ScoutApm::Agent.instance.logger.debug "Instance/Capacity: #{capacity}"
+        ScoutApm::Agent.instance.store.track_one!("Instance", "Capacity", capacity)
+
+        @processing_start_time = process_time
+      end
+    end
+  end
+end

data/lib/scout_apm/config.rb

@@ -5,89 +5,25 @@ 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 https://docs.scoutapm.com for
-# customer-focused documentation.
-#
 # application_root - override the detected directory of the application
-# collect_remote_ip - automatically capture user's IP into a Trace's Context
-# 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
-# dev_trace        - true or false. Enables always-on tracing in development environmen only
+# host             - override the default hostname detection. Default varies by environment - either system hostname, or PAAS hostname
 # 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
-# max_traces       - Internal: An experiment in trace quality, this requires a server-side setting as well. Setting this to a higher value will make your app server work harder for no benefit.
 # 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
-# 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.
-# 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
-# start_resque_server_instrument - Used in special situations with certain Resque installs
-# timeline_traces - true/false to enable sending of of the timeline trace format.
-# auto_instruments - true/false whether to install autoinstruments. Only installed if on a supported Ruby version.
-# auto_instruments_ignore - An array of file names to exclude from autoinstruments (Ex: ['application_controller']).
+# 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
 #
 # Any of these config settings can be set with an environment variable prefixed
 # by SCOUT_ and uppercasing the key: SCOUT_LOG_LEVEL for instance.
 
 module ScoutApm
   class Config
-    KNOWN_CONFIG_OPTIONS = [
-        'application_root',
-        'async_recording',
-        'collect_remote_ip',
-        'compress_payload',
-        'config_file',
-        'data_file',
-        'database_metric_limit',
-        'database_metric_report_limit',
-        'detailed_middleware',
-        'dev_trace',
-        'direct_host',
-        'disabled_instruments',
-        'enable_background_jobs',
-        'host',
-        'hostname',
-        'ignore',
-        'key',
-        'log_class',
-        'log_file_path',
-        'log_level',
-        'log_stderr',
-        'log_stdout',
-        'max_traces',
-        'monitor',
-        'name',
-        'profile',
-        'proxy',
-        'remote_agent_host',
-        'remote_agent_port',
-        'report_format',
-        'revision_sha',
-        'scm_subdirectory',
-        'start_resque_server_instrument',
-        'ssl_cert_file',
-        'uri_reporting',
-        'instrument_http_url_length',
-        'timeline_traces',
-        'auto_instruments',
-        'auto_instruments_ignore',
-
-        # Error Service Related Configuration
-        'errors_enabled',
-        'errors_ignored_exceptions',
-        'errors_filtered_params',
-        'errors_host',
-    ]
 
     ################################################################################
     # Coersions
@@ -151,12 +87,6 @@ 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)
@@ -166,25 +96,10 @@ module ScoutApm
 
 
     SETTING_COERCIONS = {
-      'async_recording' => BooleanCoercion.new,
-      'detailed_middleware' => BooleanCoercion.new,
-      'dev_trace' => BooleanCoercion.new,
-      'enable_background_jobs' => BooleanCoercion.new,
-      'ignore' => JsonCoercion.new,
-      'max_traces' => IntegerCoercion.new,
-      'monitor' => BooleanCoercion.new,
-      'collect_remote_ip' => BooleanCoercion.new,
-      'compress_payload' => BooleanCoercion.new,
-      'database_metric_limit'  => IntegerCoercion.new,
-      'database_metric_report_limit' => IntegerCoercion.new,
-      'instrument_http_url_length' => IntegerCoercion.new,
-      'start_resque_server_instrument' => BooleanCoercion.new,
-      'timeline_traces' => BooleanCoercion.new,
-      'auto_instruments' => BooleanCoercion.new,
-      'auto_instruments_ignore' => JsonCoercion.new,
-      'errors_enabled' => BooleanCoercion.new,
-      'errors_ignored_exceptions' => JsonCoercion.new,
-      'errors_filtered_params' => JsonCoercion.new,
+      "monitor"                => BooleanCoercion.new,
+      "enable_background_jobs" => BooleanCoercion.new,
+      "dev_trace"              => BooleanCoercion.new,
+      "ignore"                 => JsonCoercion.new,
     }
 
 
@@ -194,44 +109,34 @@ module ScoutApm
 
     # Load up a config instance without attempting to load a file.
     # Useful for bootstrapping.
-    def self.without_file(context)
+    def self.without_file
       overlays = [
         ConfigEnvironment.new,
         ConfigDefaults.new,
         ConfigNull.new,
       ]
-      new(context, overlays)
+      new(overlays)
     end
 
     # Load up a config instance, attempting to load a yaml file.  Allows a
     # definite location if requested, or will attempt to load the default
     # configuration file: APP_ROOT/config/scout_apm.yml
-    def self.with_file(context, file_path=nil, config={})
+    def self.with_file(file_path=nil, config={})
       overlays = [
         ConfigEnvironment.new,
-        ConfigFile.new(context, file_path, config),
+        ConfigFile.new(file_path, config),
         ConfigDefaults.new,
         ConfigNull.new,
       ]
-      new(context, overlays)
+      new(overlays)
     end
 
-    def initialize(context, overlays)
-      @context = context
+    def initialize(overlays)
       @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)
-      if ! KNOWN_CONFIG_OPTIONS.include?(key)
-        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)
+      o = @overlays.detect{ |overlay| overlay.has_key?(key) }
       raw_value = if o
                     o.value(key)
                   else
@@ -243,63 +148,18 @@ module ScoutApm
       coercion.coerce(raw_value)
     end
 
-    # Did we load anything for configuration?
-    def any_keys_found?
-      @overlays.any? { |overlay| overlay.any_keys_found? }
-    end
-
-    # Returns an array of config keys, values, and source
-    # {key: "monitor", value: "true", source: "environment"}
-    #
-    def all_settings
-      KNOWN_CONFIG_OPTIONS.inject([]) do |memo, key|
-        o = overlay_for_key(key)
-        memo << {:key => key, :value => value(key).inspect, :source => o.name}
-      end
-    end
-
-    def log_settings(logger)
-      logger.debug(
-        "Resolved Setting Values:\n" +
-        all_settings.map{|hsh| "#{hsh[:source]} - #{hsh[:key]}: #{hsh[:value]}"}.join("\n")
-      )
-    end
-
-    def logger
-      @context.logger
-    end
-
     class ConfigDefaults
       DEFAULTS = {
-        'compress_payload'       => true,
-        'detailed_middleware'    => false,
-        'dev_trace'              => false,
+        'host'                   => 'https://checkin.scoutapp.com',
         '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'                 => [],
-        'log_level'              => 'info',
-        'max_traces'             => 10,
-        '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,
-        'instrument_http_url_length' => 300,
-        'start_resque_server_instrument' => true, # still only starts if Resque is detected
-        'collect_remote_ip' => true,
-        'timeline_traces' => true,
-        'auto_instruments' => false,
-        'auto_instruments_ignore' => [],
-        'ssl_cert_file' => File.join( File.dirname(__FILE__), *%w[.. .. data cacert.pem] ),
-        'errors_enabled' => false,
-        'errors_ignored_exceptions' => %w(ActiveRecord::RecordNotFound ActionController::RoutingError),
-        'errors_filtered_params' => %w(password s3-key),
-        'errors_host' => 'https://errors.scoutapm.com',
+        'dev_trace'              => false,
+        'profile'                => true # for scoutprof
       }.freeze
 
       def value(key)
@@ -309,15 +169,6 @@ 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
 
 
@@ -332,14 +183,6 @@ module ScoutApm
       def has_key?(*)
         true
       end
-
-      def any_keys_found?
-        false
-      end
-
-      def name
-        "no-config"
-      end
     end
 
     class ConfigEnvironment
@@ -355,24 +198,13 @@ 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
     # is not found, inaccessbile, or unparsable, log a message to that effect,
     # and move on.
     class ConfigFile
-      def initialize(context, file_path=nil, config={})
-        @context = context
+      def initialize(file_path=nil, config={})
         @config = config || {}
         @resolved_file_path = file_path || determine_file_path
         load_file(@resolved_file_path)
@@ -391,20 +223,8 @@ 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
 
-      attr_reader :context
-
       def load_file(file)
         @settings = {}
         if !File.exist?(@resolved_file_path)
@@ -434,21 +254,32 @@ module ScoutApm
             @file_loaded = false
           end
         rescue Exception => e # Explicit `Exception` handling to catch SyntaxError and anything else that ERB or YAML may throw
-          logger.info("Failed loading configuration file (#{@resolved_file_path}): #{e.message}. ScoutAPM will continue starting with configuration from ENV and defaults")
+          logger.debug("Failed loading configuration file: #{e.message}. ScoutAPM will continue starting with configuration from ENV and defaults")
           @file_loaded = false
         end
       end
 
       def determine_file_path
-        File.join(context.environment.root, "config", "scout_apm.yml")
+        File.join(ScoutApm::Environment.instance.root, "config", "scout_apm.yml")
       end
 
       def app_environment
-        @config[:environment] || context.environment.env
+        @config[:environment] || ScoutApm::Environment.instance.env
       end
 
       def logger
-        context.logger
+        if ScoutApm::Agent.instance.logger
+          return ScoutApm::Agent.instance.logger
+        else
+          l = Logger.new(STDOUT)
+          if ENV["SCOUT_LOG_LEVEL"] == "debug"
+            l.level = Logger::DEBUG
+          else
+            l.level = Logger::INFO
+          end
+
+          return l
+        end
       end
     end
   end