scout_apm 2.3.5 → 2.4.0.pre

data/lib/scout_apm/synchronous_recorder.rb

@@ -4,10 +4,14 @@
 
 module ScoutApm
   class SynchronousRecorder
-    attr_reader :logger
+    attr_reader :context
 
-    def initialize(logger)
-      @logger = logger
+    def initialize(context)
+      @context = context
+    end
+
+    def logger
+      context.logger
     end
 
     def start

data/lib/scout_apm/tasks/doctor.rb

@@ -0,0 +1,75 @@
+module ScoutApm
+  module Tasks
+    class Doctor
+      def self.run!
+        new.run!
+      end
+
+      def initialize()
+      end
+
+      def run!
+        puts "Scout Doctor"
+        puts "============"
+        puts
+        puts "Detected App Server: #{agent_context.environment.app_server_integration.name}"
+        # puts "Detected Background Job: #{agent_context.environment.background_job_integration.name}"
+        puts
+        puts "Instruments:"
+        puts "----------------------------------------"
+        puts installed_instruments
+        puts
+        puts
+        puts "Configuration Settings:"
+        puts "-------------|------------------------------|-------"
+        puts "    From     |             Key              | Value "
+        puts "-------------|------------------------------|-------"
+        puts configuration_settings
+        puts
+        puts
+        puts "Misc:"
+        puts "---------------"
+        puts "Layaway Files stored at: #{agent_context.layaway.directory}"
+        puts "Logs stored at: #{log_details}"
+
+      end
+
+      def agent_context
+        ScoutApm::Agent.instance.context
+      end
+
+      def installed_instruments
+        ScoutApm::Agent.
+          instance.
+          instrument_manager.
+          installed_instruments.
+          map{|instance| "#{instance.installed? ? "Installed    " : "Not Installed"} - #{instance.class.to_s}"}.
+          join("\n")
+      end
+
+      def configuration_settings
+        all_settings = agent_context.config.all_settings
+
+        longest_key = all_settings.
+          map{|setting| setting[:key] }.
+          inject(0) { |len, key| key.length > len ? key.length : len }
+
+        format_string = "%12s | %-#{longest_key}s | %s"
+
+        all_settings.
+          map{|setting| sprintf format_string, setting[:source], setting[:key], setting[:value]}.
+          join("\n")
+      end
+
+      def log_details
+        if agent_context.logger.log_destination == STDOUT
+          "STDOUT"
+        elsif agent_context.logger.log_destination == STDERR
+          "STDERR"
+        else
+          "#{agent_context.logger.log_file_path}"
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/tasks/support.rb

@@ -0,0 +1,22 @@
+module ScoutApm
+  module Tasks
+    class Support
+      def self.run!
+        puts "Support Task"
+        new.run!
+      end
+
+      def initialize
+        @doctor = ScoutApm::Tasks::Doctor.new
+      end
+
+      def run!
+        instruments = @doctor.installed_instruments
+        config = @doctor.configuration_settings
+        collect_logs
+
+        post_data
+      end
+    end
+  end
+end

data/lib/scout_apm/tracer.rb

@@ -45,13 +45,13 @@ module ScoutApm
       # type - "View" or "ActiveRecord" and similar
       # name - "users/show", "App#find"
       def instrument_method(method_name, options = {})
-        ScoutApm::Agent.instance.logger.info "Instrumenting #{method_name}"
+        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{method_name}"
         type = options[:type] || "Custom"
         name = options[:name] || "#{self.name}/#{method_name.to_s}"
 
         instrumented_name, uninstrumented_name = _determine_instrumented_name(method_name, type)
 
-        ScoutApm::Agent.instance.logger.info "Instrumenting #{instrumented_name}, #{uninstrumented_name}"
+        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_name}, #{uninstrumented_name}"
 
         return if !_instrumentable?(method_name) or _instrumented?(instrumented_name, method_name)
 
@@ -91,7 +91,7 @@ module ScoutApm
           name = begin
                    "#{name}"
                  rescue => e
-                   ScoutApm::Agent.instance.logger.error("Error raised while interpreting instrumented name: %s, %s" % ['#{name}', e.message])
+                   ScoutApm::Agent.instance.context.logger.error("Error raised while interpreting instrumented name: %s, %s" % ['#{name}', e.message])
                    "Unknown"
                  end
 
@@ -110,14 +110,14 @@ module ScoutApm
       # The method must exist to be instrumented.
       def _instrumentable?(method_name)
         exists = method_defined?(method_name) || private_method_defined?(method_name)
-        ScoutApm::Agent.instance.logger.warn "The method [#{self.name}##{method_name}] does not exist and will not be instrumented" unless exists
+        ScoutApm::Agent.instance.context.logger.warn "The method [#{self.name}##{method_name}] does not exist and will not be instrumented" unless exists
         exists
       end
 
       # +True+ if the method is already instrumented.
       def _instrumented?(instrumented_name, method_name)
         instrumented = method_defined?(instrumented_name)
-        ScoutApm::Agent.instance.logger.warn("The method [#{self.name}##{method_name}] has already been instrumented") if instrumented
+        ScoutApm::Agent.instance.context.logger.warn("The method [#{self.name}##{method_name}] has already been instrumented") if instrumented
         instrumented
       end
 

data/lib/scout_apm/tracked_request.rb

@@ -39,26 +39,23 @@ module ScoutApm
     # this is set in the controller instumentation (ActionControllerRails3Rails4 according)
     attr_accessor :instant_key
 
-    # Whereas the instant_key gets set per-request in reponse to a URL param, dev_trace is set in the config file
-    attr_accessor :dev_trace
-
     # An object that responds to `record!(TrackedRequest)` to store this tracked request
     attr_reader :recorder
 
-    def initialize(store)
+    def initialize(agent_context, store)
+      @agent_context = agent_context
       @store = store #this is passed in so we can use a real store (normal operation) or fake store (instant mode only)
       @layers = []
       @call_set = Hash.new { |h, k| h[k] = CallSet.new }
       @annotations = {}
       @ignoring_children = 0
-      @context = Context.new
+      @context = Context.new(agent_context)
       @root_layer = nil
       @error = false
       @stopping = false
       @instant_key = nil
       @mem_start = mem_usage
-      @dev_trace =  ScoutApm::Agent.instance.config.value('dev_trace') && ScoutApm::Agent.instance.environment.env == "development"
-      @recorder = ScoutApm::Agent.instance.recorder
+      @recorder = agent_context.recorder
 
       ignore_request! if @recorder.nil?
     end
@@ -152,9 +149,15 @@ module ScoutApm
       @call_set[layer.name].update!(layer.desc)
     end
 
+    # Grab backtraces more aggressively when running in dev trace mode
+    def backtrace_threshold
+      @agent_context.dev_trace_enabled? ? 0.05 : 0.5 # the minimum threshold in seconds to record the backtrace for a metric.
+    end
+
     # This may be in bytes or KB based on the OSX. We store this as-is here and only do conversion to MB in Layer Converters.
+    # XXX: Move this to environment?
     def mem_usage
-      ScoutApm::Instruments::Process::ProcessMemory.rss
+      ScoutApm::Instruments::Process::ProcessMemory.new(@agent_context).rss
     end
 
     def capture_mem_delta!
@@ -261,7 +264,7 @@ module ScoutApm
       restore_store if @store.nil?
 
       # Bail out early if the user asked us to ignore this uri
-      return if ScoutApm::Agent.instance.ignored_uris.ignore?(annotations[:uri])
+      return if @agent_context.ignored_uris.ignore?(annotations[:uri])
 
       converters = [
         LayerConverters::Histograms,
@@ -279,7 +282,7 @@ module ScoutApm
       layer_finder = LayerConverters::FindLayerByType.new(self)
       walker = LayerConverters::DepthFirstWalker.new(self.root_layer)
       converters = converters.map do |klass|
-        instance = klass.new(self, layer_finder, @store)
+        instance = klass.new(@agent_context, self, layer_finder, @store)
         instance.register_hooks(walker)
         instance
       end
@@ -292,26 +295,8 @@ module ScoutApm
         trace = converter.call
         ScoutApm::InstantReporting.new(trace, instant_key).call
       end
-
-      if web? || job?
-        ensure_background_worker
-      end
-    end
-
-    # Ensure the background worker thread is up & running - a fallback if other
-    # detection doesn't achieve this at boot.
-    def ensure_background_worker
-      agent = ScoutApm::Agent.instance
-      agent.start(:skip_app_server_check => true) unless agent.started?
-
-      if agent.start_background_worker(:quiet)
-        agent.logger.info("Force Started BG Worker")
-      end
-    rescue => e
-      true
     end
 
-
     # Only call this after the request is complete
     def unique_name
       return nil if ignoring_request?
@@ -376,11 +361,6 @@ module ScoutApm
       @ignoring_children > 0
     end
 
-    # Grab backtraces more aggressively when running in dev trace mode
-    def backtrace_threshold
-      dev_trace ? 0.05 : 0.5 # the minimum threshold in seconds to record the backtrace for a metric.
-    end
-
     ################################################################################
     # Ignoring the rest of a request
     ################################################################################
@@ -390,6 +370,10 @@ module ScoutApm
     # layers, and delete any existing layer info.  This class will still exist,
     # and respond to methods as normal, but `record!` won't be called, and no
     # data will be recorded.
+    #
+    # We still need to keep track of the current layer depth (via
+    # @ignoring_depth counter) so we know when to report that the class was
+    # "reported", and ready to be recreated for the next request.
 
     def ignore_request!
       return if @ignoring_request
@@ -425,9 +409,13 @@ module ScoutApm
     end
 
     def logger
-      ScoutApm::Agent.instance.logger
+      @agent_context.logger
     end
 
+    ###########################
+    #  Serialization Helpers
+    ###########################
+
     # Actually go fetch & make-real any lazily created data.
     # Clean up any cleverness in objects.
     # Makes this object ready to be Marshal Dumped (or otherwise serialized)
@@ -440,7 +428,7 @@ module ScoutApm
     # Go re-fetch the store based on what the Agent's official one is. Used
     # after hydrating a dumped TrackedRequest
     def restore_store
-      @store = ScoutApm::Agent.instance.store
+      @store = @agent_context.store
     end
   end
 end

data/lib/scout_apm/utils/backtrace_parser.rb

@@ -11,7 +11,7 @@ module ScoutApm
 
       attr_reader :call_stack
 
-      def initialize(call_stack, root=ScoutApm::Environment.instance.root)
+      def initialize(call_stack, root=ScoutApm::Agent.instance.context.environment.root)
         @call_stack = call_stack
         # We can't use a constant as it'd be too early to fetch environment info
         #

data/lib/scout_apm/utils/installed_gems.rb

@@ -1,10 +1,14 @@
 module ScoutApm
   module Utils
     class InstalledGems
-      attr_reader :logger
+      attr_reader :context
 
-      def initialize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
+      def initialize(context)
+        @context = context
+      end
+
+      def logger
+        context.logger
       end
 
       def run

data/lib/scout_apm/utils/klass_helper.rb

@@ -5,6 +5,12 @@ module ScoutApm
       # KlassHelper.defined?("ActiveRecord::Base")   #=> true / false
 
       def self.defined?(*names)
+        lookup(*names) != :missing_class
+      end
+
+      # KlassHelper.lookup("ActiveRecord::Base") => ActiveRecord::Base
+      # KlassHelper.lookup("ActiveRecord::SomethingThatDoesNotExist") => :missing_class
+      def self.lookup(*names)
         if names.length == 1
           names = names[0].split("::")
         end
@@ -15,11 +21,11 @@ module ScoutApm
           begin
             obj = obj.const_get(name)
           rescue NameError
-            return false
+            return :missing_class
           end
         end
 
-        true
+        obj
       end
     end
   end

data/lib/scout_apm/utils/scm.rb

@@ -4,7 +4,7 @@ module ScoutApm
     class Scm
       # Takes an *already relative* path +path+
       # Returns a relative path, prepending the configured +scm_subdirectory+ environment string
-      def self.relative_scm_path(path, scm_subdirectory = ScoutApm::Environment.instance.scm_subdirectory)
+      def self.relative_scm_path(path, scm_subdirectory = ScoutApm::Agent.instance.context.environment.scm_subdirectory)
         @@scm_subdirectory ||= scm_subdirectory.sub(/^\//, '')
         @@scm_subdirectoy_blank ||= @@scm_subdirectory.empty?
         @@scm_subdirectoy_blank ? path : File.join(@@scm_subdirectory, path)

data/lib/scout_apm/utils/sql_sanitizer.rb

@@ -16,7 +16,7 @@ module ScoutApm
 
       def initialize(sql)
         @raw_sql = sql
-        @database_engine = ScoutApm::Environment.instance.database_engine
+        @database_engine = ScoutApm::Agent.instance.context.environment.database_engine
         @sanitized = false # only sanitize once.
       end
 
@@ -74,19 +74,17 @@ module ScoutApm
         encodings.all?{|enc| Encoding.find(enc) rescue false}
       end
 
-      MAX_SQL_LENGTH = 16384
-
       def scrubbed(str)
-        return '' if !str.is_a?(String) || str.length > MAX_SQL_LENGTH # safeguard - don't sanitize or scrub large SQL statements
+        return '' if !str.is_a?(String) || str.length > 4000 # safeguard - don't sanitize or scrub large SQL statements
         return str if !str.respond_to?(:encode) # Ruby <= 1.8 doesn't have string encoding
         return str if str.valid_encoding? # Whatever encoding it is, it is valid and we can operate on it
-        ScoutApm::Agent.instance.logger.debug "Scrubbing invalid sql encoding."
+        ScoutApm::Agent.instance.context.logger.debug "Scrubbing invalid sql encoding."
         if str.respond_to?(:scrub) # Prefer to scrub before we have to convert
           return str.scrub('_')
         elsif has_encodings?(['UTF-8', 'binary'])
           return str.encode('UTF-8', 'binary', :invalid => :replace, :undef => :replace, :replace => '_')
         end
-        ScoutApm::Agent.instance.logger.debug "Unable to scrub invalid sql encoding."
+        ScoutApm::Agent.instance.context.logger.debug "Unable to scrub invalid sql encoding."
         ''
       end
 

data/lib/scout_apm/version.rb

@@ -1,4 +1,4 @@
 module ScoutApm
-  VERSION = "2.3.5"
+  VERSION = "2.4.0.pre"
 end
 

data/lib/tasks/doctor.rake

@@ -0,0 +1,11 @@
+namespace :scout do
+  desc "Prints out details of the detected environment"
+  task :doctor => :environment do
+    ScoutApm::Tasks::Doctor.run!
+  end
+
+  desc "Collect logs, settings and environment to help debug issues"
+  task :support => :environment do
+    ScoutApm::Tasks::Support.run!
+  end
+end

data/test/test_helper.rb

@@ -41,6 +41,14 @@ class FakeConfigOverlay
   def has_key?(key)
     @values.has_key?(key)
   end
+
+  def name
+    "agent-test-config-overlay"
+  end
+
+  def any_keys_found?
+    true
+  end
 end
 
 class FakeEnvironment
@@ -66,7 +74,7 @@ class Minitest::Test
   end
 
   def teardown
-    ScoutApm::Agent.instance.shutdown
+    ScoutApm::Agent.instance.stop_background_worker
     File.delete(DATA_FILE_PATH) if File.exist?(DATA_FILE_PATH)
   end
 
@@ -85,8 +93,13 @@ class Minitest::Test
     FakeEnvironment.new(values)
   end
 
+  # XXX: Make it easy to override context here?
   def make_fake_config(values)
-    ScoutApm::Config.new(FakeConfigOverlay.new(values))
+    ScoutApm::Config.new(agent_context, [FakeConfigOverlay.new(values), ScoutApm::Config::ConfigNull.new] )
+  end
+
+  def agent_context
+    ScoutApm::AgentContext.new
   end
 
   DATA_FILE_DIR = File.dirname(__FILE__) + '/tmp'