scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/tracked_request.rb

@@ -26,6 +26,10 @@ module ScoutApm
     # Can be nil if we never reach a Rails Controller
     attr_reader :headers
 
+    # What kind of request is this? A trace of a web request, or a background job?
+    # Use job! and web! to set, and job? and web? to query
+    attr_reader :request_type
+
     # This maintains a lookup hash of Layer names and call counts. It's used to trigger fetching a backtrace on n+1 calls.
     # Note that layer names might not be Strings - can alse be Utils::ActiveRecordMetricName. Also, this would fail for layers
     # with same names across multiple types.
@@ -35,70 +39,38 @@ module ScoutApm
     # this is set in the controller instumentation (ActionControllerRails3Rails4 according)
     attr_accessor :instant_key
 
-    # An object that responds to `record!(TrackedRequest)` to store this tracked request
-    attr_reader :recorder
-
-    # If specified, an override for the name of the request. If unspecified,
-    # the name is determined from the name of the Controller or Job layer.
-    attr_accessor :name_override
-
-    # A unique, but otherwise meaningless String to identify this request. UUID
-    attr_reader :transaction_id
-
-    # When we see these layers, it means a real request is going through the
-    # system. We toggle a flag to turn on some slightly more expensive
-    # instrumentation (backtrace collection and the like) that would be too
-    # expensive in situations where the framework is constantly churning. We
-    # see that on Sidekiq.
-    REQUEST_TYPES = ["Controller", "Job"]
+    # 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
 
-    # Layers of type 'AutoInstrument' are not recorded if their total_call_time doesn't exceed this threshold.
-    # AutoInstrument layers are frequently of short duration. This throws out this deadweight that is unlikely to be optimized.
-    AUTO_INSTRUMENT_TIMING_THRESHOLD = 5/1_000.0 # units = seconds
-
-    def initialize(agent_context, store)
-      @agent_context = agent_context
+    def initialize(store)
       @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(agent_context)
+      @context = Context.new
       @root_layer = nil
       @error = false
-      @stopping = false
       @instant_key = nil
       @mem_start = mem_usage
-      @recorder = agent_context.recorder
-      @real_request = false
-      @transaction_id = ScoutApm::Utils::TransactionId.new.to_s
-      ignore_request! if @recorder.nil?
+      @dev_trace =  ScoutApm::Agent.instance.config.value('dev_trace') && Rails.env.development?
     end
 
     def start_layer(layer)
-      # If we're already stopping, don't do additional layers
-      return if stopping?
-
-      return if ignoring_children?
+      if ignoring_children?
+        return
+      end
 
-      return ignoring_start_layer if ignoring_request?
+      layer.start_sampling
 
       start_request(layer) unless @root_layer
-
-      if REQUEST_TYPES.include?(layer.type)
-        real_request!
-      end
+      @layers[-1].add_child(layer) if @layers.any?
       @layers.push(layer)
     end
 
     def stop_layer
-      # If we're already stopping, don't do additional layers
-      return if stopping?
-
       return if ignoring_children?
 
-      return ignoring_stop_layer if ignoring_request?
-
       layer = @layers.pop
 
       # Safeguard against a mismatch in the layer tracking in an instrument.
@@ -106,19 +78,15 @@ module ScoutApm
       # lined up correctly. If stop_layer gets called twice, when it should
       # only have been called once you'll end up with this error.
       if layer.nil?
-        logger.warn("Error stopping layer, was nil. Root Layer: #{@root_layer.inspect}")
+        ScoutApm::Agent.instance.logger.warn("Error stopping layer, was nil. Root Layer: #{@root_layer.inspect}")
         stop_request
         return
       end
 
+      layer.record_traces!
       layer.record_stop_time!
       layer.record_allocations!
 
-      # Must follow layer.record_stop_time! as the total_call_time is used to determine if the layer is significant.
-      return if layer_insignificant?(layer)
-
-      @layers[-1].add_child(layer) if @layers.any?
-
       # This must be called before checking if a backtrace should be collected as the call count influences our capture logic.
       # We call `#update_call_counts in stop layer to ensure the layer has a final desc. Layer#desc is updated during the AR instrumentation flow.
       update_call_counts!(layer)
@@ -126,21 +94,13 @@ module ScoutApm
         layer.capture_backtrace!
       end
 
-
       if finalized?
         stop_request
+      else
+        continue_sampling_for_layers if ScoutApm::Agent.instance.config.value('profile')
       end
     end
 
-    def real_request!
-      @real_request = true
-    end
-
-    # Have we seen a "controller" or "job" layer so far?
-    def real_request?
-      @real_request
-    end
-
     # Grab the currently running layer. Useful for adding additional data as we
     # learn it. This is useful in ActiveRecord instruments, where we start the
     # instrumentation early, and gradually learn more about the request that
@@ -155,12 +115,6 @@ module ScoutApm
 
     BACKTRACE_BLACKLIST = ["Controller", "Job"]
     def capture_backtrace?(layer)
-      return if ignoring_request?
-
-      # A backtrace has already been recorded. This happens with autoinstruments as
-      # the partial backtrace is set when creating the layer.
-      return false if layer.backtrace
-
       # Never capture backtraces for this kind of layer. The backtrace will
       # always be 100% framework code.
       return false if BACKTRACE_BLACKLIST.include?(layer.type)
@@ -168,7 +122,7 @@ module ScoutApm
       # Only capture backtraces if we're in a real "request". Otherwise we
       # can spend lot of time capturing backtraces from the internals of
       # Sidekiq, only to throw them away immediately.
-      return false unless real_request?
+      return false unless (web? || job?)
 
       # Capture any individually slow layer.
       return true if layer.total_exclusive_time > backtrace_threshold
@@ -180,34 +134,14 @@ module ScoutApm
       false
     end
 
-    # Returns +true+ if the total call time of AutoInstrument layers exceeds +AUTO_INSTRUMENT_TIMING_THRESHOLD+ and
-    # records a Histogram of insignificant / significant layers by file name.
-    def layer_insignificant?(layer)
-      result = false # default is significant
-      if layer.type == 'AutoInstrument'
-        if layer.total_call_time < AUTO_INSTRUMENT_TIMING_THRESHOLD
-          result = true # not significant
-        end
-        # 0 = not significant, 1 = significant
-        @agent_context.auto_instruments_layer_histograms.add(layer.file_name, (result ? 0 : 1))
-      end
-      result
-    end
-
     # Maintains a lookup Hash of call counts by layer name. Used to determine if we should capture a backtrace.
     def update_call_counts!(layer)
       @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.new(@agent_context).rss
+      ScoutApm::Instruments::Process::ProcessMemory.rss
     end
 
     def capture_mem_delta!
@@ -224,6 +158,13 @@ module ScoutApm
       @layers.none?
     end
 
+    def continue_sampling_for_layers
+      if last_traced_layer = @layers.select{|layer| layer.traced?}.last
+        ScoutApm::Instruments::Stacks.update_indexes(@layers.last.frame_index, @layers.last.trace_index)
+        ScoutApm::Instruments::Stacks.start_sampling
+      end
+    end
+
     # Run at the beginning of the whole request
     #
     # * Capture the first layer as the root_layer
@@ -235,15 +176,21 @@ module ScoutApm
     #
     # * Send the request off to be stored
     def stop_request
-      @stopping = true
-
-      if @recorder
-        @recorder.record!(self)
+      if ScoutApm::Agent.instance.config.value('profile')
+        ScoutApm::Instruments::Stacks.stop_sampling(true)
+        ScoutApm::Instruments::Stacks.update_indexes(0, 0)
       end
+      record!
     end
 
-    def stopping?
-      @stopping
+    # Enable ScoutProf for this thread
+    def enable_profiled_thread!
+        ScoutApm::Instruments::Stacks.add_profiled_thread
+    end
+
+    # Disable ScoutProf for this thread
+    def disable_profiled_thread!
+        ScoutApm::Instruments::Stacks.remove_profiled_thread
     end
 
     ###################################
@@ -272,9 +219,23 @@ module ScoutApm
       @headers = headers
     end
 
-    def instant?
-      return false if ignoring_request?
+    def job!
+      @request_type = "job"
+    end
+
+    def job?
+      request_type == "job"
+    end
 
+    def web!
+      @request_type = "web"
+    end
+
+    def web?
+      request_type == "web"
+    end
+
+    def instant?
       instant_key
     end
 
@@ -282,109 +243,62 @@ module ScoutApm
     # Persist the Request
     ###################################
 
-    def recorded!
-      @recorded = true
-    end
-
     # Convert this request to the appropriate structure, then report it into
     # the peristent Store object
     def record!
-      recorded!
-
-      return if ignoring_request?
-
-      # If we didn't have store, but we're trying to record anyway, go
-      # figure that out. (this happens in Remote Agent scenarios)
-      restore_from_dump! if @agent_context.nil?
+      @recorded = true
 
       # Bail out early if the user asked us to ignore this uri
-      return if @agent_context.ignored_uris.ignore?(annotations[:uri])
-
-      apply_name_override
-
-      @agent_context.transaction_time_consumed.add(unique_name, root_layer.total_call_time)
-
-      context.add(:transaction_id => transaction_id)
-
-      # Make a constant, then call converters.dup.each so it isn't inline?
-      converters = {
-        :histograms => LayerConverters::Histograms,
-        :metrics => LayerConverters::MetricConverter,
-        :errors => LayerConverters::ErrorConverter,
-        :allocation_metrics => LayerConverters::AllocationMetricConverter,
-        :queue_time => LayerConverters::RequestQueueTimeConverter,
-        :job => LayerConverters::JobConverter,
-        :db => LayerConverters::DatabaseConverter,
-
-        :slow_job => LayerConverters::SlowJobConverter,
-        :slow_req => LayerConverters::SlowRequestConverter,
-
-        # This is now integrated into the slow_job and slow_req converters, so that
-        # we get the exact same set of traces either way. We can call it
-        # directly when we move away from the legacy trace styles.
-        # :traces => LayerConverters::TraceConverter,
-      }
-
-      walker = LayerConverters::DepthFirstWalker.new(self.root_layer)
-      converter_instances = converters.inject({}) do |memo, (slug, klass)|
-        instance = klass.new(@agent_context, self, layer_finder, @store)
-        instance.register_hooks(walker)
-        memo[slug] = instance
-        memo
-      end
-      walker.walk
-      converter_results = converter_instances.inject({}) do |memo, (slug,i)|
-        memo[slug] = i.record!
-        memo
+      return if ScoutApm::Agent.instance.ignored_uris.ignore?(annotations[:uri])
+
+      # Update immediate and long-term histograms for both job and web requests
+      if unique_name != :unknown
+        ScoutApm::Agent.instance.request_histograms.add(unique_name, root_layer.total_call_time)
+        ScoutApm::Agent.instance.request_histograms_by_time[@store.current_timestamp].
+          add(unique_name, root_layer.total_call_time)
       end
 
-      @agent_context.extensions.run_transaction_callbacks(converter_results,context,layer_finder.scope)
+      metrics = LayerConverters::MetricConverter.new(self).call
+      @store.track!(metrics)
 
-      # If there's an instant_key, it means we need to report this right away
-      if web? && instant?
-        converter = converters.find{|c| c.class == LayerConverters::SlowRequestConverter}
-        trace = converter.call
-        ScoutApm::InstantReporting.new(trace, instant_key).call
-      end
+      error_metrics = LayerConverters::ErrorConverter.new(self).call
+      @store.track!(error_metrics)
 
-      if web? || job?
-        ensure_background_worker
-      end
-    end
+      allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
+      @store.track!(allocation_metrics)
 
-    # This request is a job transaction iff it has a 'Job' layer
-    # Use this only during recording
-    def job?
-      layer_finder.job != nil
-    end
+      if web?
+        # Don't #call this - that's the job of the ScoredItemSet later.
+        slow_converter = LayerConverters::SlowRequestConverter.new(self)
+        @store.track_slow_transaction!(slow_converter)
 
-    # This request is a web transaction iff it has a 'Controller' layer
-    # Use this only during recording
-    def web?
-      layer_finder.controller != nil
-    end
+        queue_time_metrics = LayerConverters::RequestQueueTimeConverter.new(self).call
+        @store.track!(queue_time_metrics)
+
+        # If there's an instant_key, it means we need to report this right away
+        if instant?
+          trace = slow_converter.call
+          ScoutApm::InstantReporting.new(trace, instant_key).call()
+        end
+      end
 
+      if job?
+        job_metrics = LayerConverters::JobConverter.new(self).call
+        @store.track_job!(job_metrics)
 
-    def layer_finder
-      @layer_finder ||= LayerConverters::FindLayerByType.new(self)
-    end
+        job_converter = LayerConverters::SlowJobConverter.new(self)
+        @store.track_slow_job!(job_converter)
+      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
-    rescue => e
-      true
-    end
+      allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
+      @store.track!(allocation_metrics)
 
+    end
 
     # Only call this after the request is complete
     def unique_name
-      return nil if ignoring_request?
-
       @unique_name ||= begin
-                         scope_layer = LayerConverters::FindLayerByType.new(self).scope
+                         scope_layer = LayerConverters::ConverterBase.new(self).scope_layer
                          if scope_layer
                            scope_layer.legacy_metric_name
                          else
@@ -397,8 +311,6 @@ module ScoutApm
     # Used to know when we should just create a new one (don't attempt to add
     # data to an already-recorded request). See RequestManager
     def recorded?
-      return ignoring_recorded? if ignoring_request?
-
       @recorded
     end
 
@@ -443,88 +355,9 @@ module ScoutApm
       @ignoring_children > 0
     end
 
-    ################################################################################
-    # Ignoring the rest of a request
-    ################################################################################
-
-    # At any point in the request, calling code or instrumentation can call
-    # `ignore_request!` to immediately stop recording any information about new
-    # 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
-
-      # Set instance variable
-      @ignoring_request = true
-
-      # Store data we'll need
-      @ignoring_depth = @layers.length
-
-      # Clear data
-      @layers = []
-      @root_layer = nil
-      @call_set = nil
-      @annotations = {}
-      @instant_key = nil
-    end
-
-    def ignoring_request?
-      @ignoring_request
-    end
-
-    def ignoring_start_layer
-      @ignoring_depth += 1
-    end
-
-    def ignoring_stop_layer
-      @ignoring_depth -= 1
-    end
-
-    def ignoring_recorded?
-      @ignoring_depth <= 0
-    end
-
-    def 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)
-    def prepare_to_dump!
-      @call_set = nil
-      @store = nil
-      @recorder = nil
-      @agent_context = nil
-    end
-
-    # Go re-fetch the store based on what the Agent's official one is. Used
-    # after hydrating a dumped TrackedRequest
-    def restore_from_dump!
-      @agent_context = ScoutApm::Agent.instance.context
-      @recorder = @agent_context.recorder
-      @store = @agent_context.store
-    end
-
-    private
-
-    def apply_name_override
-      return unless name_override
-
-      scope_layer = layer_finder.scope
-      if scope_layer
-        scope_layer.name = name_override
-      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
   end
 end

data/lib/scout_apm/utils/active_record_metric_name.rb

@@ -1,42 +1,32 @@
 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
 
       # Converts an SQL string and the name (typically assigned automatically
       # by rails) into a Scout metric_name.
       #
-      # This prefers to use the ActiveRecord-provided name over parsing SQL as parsing is slower.
-      #
       # sql: SELECT "places".* FROM "places"  ORDER BY "places"."position" ASC
       # name: Place Load
       # metric_name: Place/find
       def to_s
-        return @to_s if @to_s
-        parsed = parse_operation
-        if parsed
-          @to_s = "#{model}/#{parsed}"
+        return DEFAULT_METRIC unless name
+        return DEFAULT_METRIC unless model && operation
+
+        if parsed = parse_operation
+          "#{model}/#{parsed}"
         else
-          @to_s = regex_name(sql)
+          "SQL/other"
         end
       end
 
-      # This only returns a value if a name is provided via +initialize+.
-      def model
-        parts.first
-      end
-
-      # This only returns a value if a name is provided via +initialize+.
-      def normalized_operation
-        parse_operation
-      end
-
       # For the layer lookup.
       def hash
         h = name.downcase.hash
@@ -54,14 +44,16 @@ module ScoutApm
 
       private
 
-      # This only returns a value if a name is provided via +initialize+.
+      def model
+        parts.first
+      end
+
       def operation
         if parts.length >= 2
           parts[1].downcase
         end
       end
 
-      # This only returns a value if a name is provided via +initialize+.
       def parts
         name.split(" ")
       end
@@ -80,73 +72,6 @@ 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\(.*?\)'
-      BEGIN_STATEMENT = 'BEGIN'.freeze # BEGIN is a reserved keyword
-      COMMIT = 'COMMIT'.freeze
-
-      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].gsub(/\W/,'').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}"
-        elsif sql == BEGIN_STATEMENT
-          "SQL/#{BEGIN_STATEMENT.downcase}"
-        elsif sql == COMMIT
-          "SQL/#{COMMIT.downcase}"
-        else
-          UNKNOWN_LABEL
-        end
-      rescue
-        UNKNOWN_LABEL
-      end
     end
   end
 end

data/lib/scout_apm/utils/backtrace_parser.rb

@@ -6,15 +6,12 @@ require 'scout_apm/environment'
 module ScoutApm
   module Utils
     class BacktraceParser
-      # will return this many backtrace frames from the app stack.
-      APP_FRAMES = 8
+
+      APP_FRAMES = 3 # will return up to 3 frames from the app stack.
 
       attr_reader :call_stack
 
-      # call_stack - an +Array+ of calls, typically generated via the +caller+ method. 
-      # Example single line: 
-      # "/Users/dlite/.rvm/rubies/ruby-2.4.5/lib/ruby/2.4.0/irb/workspace.rb:87:in `eval'"
-      def initialize(call_stack, root=ScoutApm::Agent.instance.context.environment.root)
+      def initialize(call_stack, root=ScoutApm::Environment.instance.root)
         @call_stack = call_stack
         # We can't use a constant as it'd be too early to fetch environment info
         #
@@ -27,7 +24,7 @@ module ScoutApm
         stack = []
         call_stack.each do |c|
           if m = c.match(@@app_dir_regex)
-            stack << ScoutApm::Utils::Scm.relative_scm_path(m[1])
+            stack << m[1]
             break if stack.size == APP_FRAMES
           end
         end