scout_apm 3.0.0.pre13 → 3.0.0.pre14

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
@@ -113,7 +110,7 @@ module ScoutApm
       if finalized?
         stop_request
       else
-        continue_sampling_for_layers if ScoutApm::Agent.instance.config.value('profile')
+        continue_sampling_for_layers if @agent_context.config.value('profile')
       end
     end
 
@@ -157,9 +154,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!
@@ -196,7 +199,7 @@ module ScoutApm
     def stop_request
       @stopping = true
 
-      if ScoutApm::Agent.instance.config.value('profile')
+      if @agent_context.config.value('profile')
         ScoutApm::Instruments::Stacks.stop_sampling(true)
         ScoutApm::Instruments::Stacks.update_indexes(0, 0)
       end
@@ -288,7 +291,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,
@@ -306,7 +309,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
@@ -319,8 +322,26 @@ 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
+
+      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?
@@ -385,11 +406,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
     ################################################################################
@@ -399,6 +415,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
@@ -434,9 +454,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)
@@ -449,7 +473,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/active_record_metric_name.rb

@@ -1,12 +1,11 @@
 module ScoutApm
   module Utils
     class ActiveRecordMetricName
-      DEFAULT_METRIC = "SQL/Unknown"
-
       attr_reader :sql, :name
+      DEFAULT_METRIC = 'SQL/other'.freeze
 
       def initialize(sql, name)
-        @sql = sql
+        @sql = sql || ""
         @name = name.to_s
       end
 
@@ -17,13 +16,11 @@ module ScoutApm
       # name: Place Load
       # metric_name: Place/find
       def to_s
-        return DEFAULT_METRIC unless name
-        return DEFAULT_METRIC unless model && operation
-
-        if parsed = parse_operation
+        parsed = parse_operation
+        if parsed
           "#{model}/#{parsed}"
         else
-          "SQL/other"
+          regex_name(sql)
         end
       end
 
@@ -76,6 +73,67 @@ module ScoutApm
           end
         end
       end
+
+
+      ########################
+      #  Regex based naming  #
+      ########################
+      #
+      WHITE_SPACE = '\s*'
+      REGEX_OPERATION = '(SELECT|UPDATE|INSERT|DELETE)'
+      FROM = 'FROM'
+      INTO = 'INTO'
+      NON_GREEDY_CONSUME = '.*?'
+      TABLE = '(?:"|`)?(.*?)(?:"|`)?\s'
+      COUNT = 'COUNT\(.*?\)'
+
+      SELECT_REGEX = /\A#{WHITE_SPACE}(SELECT)#{WHITE_SPACE}(#{COUNT})?#{NON_GREEDY_CONSUME}#{FROM}#{WHITE_SPACE}#{TABLE}/i.freeze
+      UPDATE_REGEX = /\A#{WHITE_SPACE}(UPDATE)#{WHITE_SPACE}#{TABLE}/i.freeze
+      INSERT_REGEX = /\A#{WHITE_SPACE}(INSERT)#{WHITE_SPACE}#{INTO}#{WHITE_SPACE}#{TABLE}/i.freeze
+      DELETE_REGEX = /\A#{WHITE_SPACE}(DELETE)#{WHITE_SPACE}#{FROM}#{TABLE}/i.freeze
+
+      COUNT_LABEL = 'count'.freeze
+      SELECT_LABEL = 'find'.freeze
+      UPDATE_LABEL = 'save'.freeze
+      INSERT_LABEL = 'create'.freeze
+      DELETE_LABEL = 'destroy'.freeze
+      UNKNOWN_LABEL = 'SQL/other'.freeze
+
+      # Attempt to do some basic parsing of SQL via regexes to extract the SQL
+      # verb (select, update, etc) and the table being operated on.
+      #
+      # This is a fallback from what ActiveRecord gives us, we prefer its
+      # names. But sometimes it is giving us a no-name query, and we have to
+      # attempt to figure it out ourselves.
+      #
+      # This relies on ActiveSupport's classify method. If it's not present,
+      # just skip the attempt to rename here. This could happen in a Grape or
+      # Sinatra application that doesn't import ActiveSupport. At this point,
+      # you're already using ActiveRecord, so it's likely loaded anyway.
+      def regex_name(sql)
+        # We rely on the ActiveSupport inflections code here. Bail early if we can't use it.
+        return UNKNOWN_LABEL unless UNKNOWN_LABEL.respond_to?(:classify)
+
+        if match = SELECT_REGEX.match(sql)
+          operation =
+            if match[2]
+              COUNT_LABEL
+            else
+              SELECT_LABEL
+            end
+          "#{match[3].classify}/#{operation}"
+        elsif match = UPDATE_REGEX.match(sql)
+          "#{match[2].classify}/#{UPDATE_LABEL}"
+        elsif match = INSERT_REGEX.match(sql)
+          "#{match[2].classify}/#{INSERT_LABEL}"
+        elsif match = DELETE_REGEX.match(sql)
+          "#{match[2].classify}/#{DELETE_LABEL}"
+        else
+          UNKNOWN_LABEL
+        end
+      rescue
+        UNKNOWN_LABEL
+      end
     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