scout_apm 2.1.32 → 2.2.0.pre0

data/lib/scout_apm/instruments/percentile_sampler.rb

@@ -1,53 +1,36 @@
 module ScoutApm
   module Instruments
-
-    class HistogramReport
-      attr_reader :name
-      attr_reader :histogram
-
-      def initialize(name, histogram)
-        @name = name
-        @histogram = histogram
-      end
-
-      def combine!(other)
-        raise "Mismatched Histogram Names" unless name == other.name
-        histogram.combine!(other.histogram)
-        self
-      end
-    end
-
     class PercentileSampler
       attr_reader :logger
 
-      # A hash of { time => RequestHistograms }
-      attr_reader :histograms
+      attr_reader :percentiles
 
-      def initialize(logger, histograms)
+      def initialize(logger, percentiles)
         @logger = logger
-        @histograms = histograms
+        @percentiles = Array(percentiles)
       end
 
       def human_name
-        'Percentiles'
+        "Percentiles"
       end
 
-      def metrics(timestamp, store)
-        store.track_histograms!(percentiles(timestamp), :timestamp => timestamp)
-      end
-
-      def percentiles(time)
-        result = []
-
-        histogram = histograms.delete(time)
-
-        return result unless histogram
-
-        histogram.each_name do |name|
-          result << HistogramReport.new(name, histogram.raw(name))
+      # Gets the 95th%ile for the time requested
+      def metrics(time)
+        ms = {}
+        histos = ScoutApm::Agent.instance.request_histograms_by_time[time]
+        histos.each_name do |name|
+          percentiles.each do |percentile|
+            meta = MetricMeta.new("Percentile/#{percentile}/#{name}")
+            stat = MetricStats.new
+            stat.update!(histos.quantile(name, percentile))
+            ms[meta] = stat
+          end
         end
 
-        result
+        # Wipe the histograms we just collected data on
+        ScoutApm::Agent.instance.request_histograms_by_time.delete(time)
+
+        ms
       end
     end
   end

data/lib/scout_apm/instruments/process/process_cpu.rb

@@ -29,17 +29,16 @@ module ScoutApm
           "Process CPU"
         end
 
-        def metrics(timestamp, store)
+        def metrics(_time)
           result = run
           if result
             meta = MetricMeta.new("#{metric_type}/#{metric_name}")
             stat = MetricStats.new(false)
             stat.update!(result)
-            store.track!({ meta => stat }, :timestamp => timestamp)
+            { meta => stat }
           else
             {}
           end
-
         end
 
         # TODO: Figure out a good default instead of nil

data/lib/scout_apm/instruments/process/process_memory.rb

@@ -33,20 +33,20 @@ module ScoutApm
           "Process Memory"
         end
 
-        def metrics(timestamp, store)
+        def metrics(_time)
           result = run
           if result
             meta = MetricMeta.new("#{metric_type}/#{metric_name}")
             stat = MetricStats.new(false)
             stat.update!(result)
-            store.track!({ meta => stat }, :timestamp => timestamp)
+            { meta => stat }
           else
             {}
           end
         end
 
         def run
-          self.class.rss_in_mb.tap { |res| logger.debug "#{human_name}: #{res.inspect}" }
+          self.class.rss_in_mb.tap { |res| logger.debug "#{human_name}: #{res.inspect}" }      
         end
       end
     end

data/lib/scout_apm/layaway.rb

@@ -7,23 +7,19 @@
 #
 module ScoutApm
   class Layaway
+    # How old a file needs to be in Seconds before it gets reported.
+    REPORTING_AGE = 120
+
     # How long to let a stale file sit before deleting it.
     # Letting it sit a bit may be useful for debugging
     STALE_AGE = 10 * 60
 
-    # Failsafe to prevent writing layaway files if for some reason they are not being cleaned up
-    MAX_FILES_LIMIT = 5000
-
     # A strftime format string for how we render timestamps in filenames.
     # Must be sortable as an integer
     TIME_FORMAT = "%Y%m%d%H%M"
 
-    attr_accessor :config
-    attr_reader :environment
-
-    def initialize(config, environment)
-      @config = config
-      @environment = environment
+    def initialize(directory=nil)
+      @directory = directory
     end
 
     # Returns a Pathname object with the fully qualified directory where the layaway files can be placed.
@@ -34,12 +30,12 @@ module ScoutApm
     def directory
       return @directory if @directory
 
-      data_file = config.value("data_file")
-      data_file = File.dirname(data_file) if data_file && !File.directory?(data_file)
+      data_file = ScoutApm::Agent.instance.config.value("data_file")
+      data_file = File.dirname(data_file) if data_file && !File.directory?
 
       candidates = [
         data_file,
-        "#{environment.root}/tmp",
+        "#{ScoutApm::Agent.instance.environment.root}/tmp",
         "/tmp"
       ].compact
 
@@ -48,11 +44,7 @@ module ScoutApm
       @directory = Pathname.new(found)
     end
 
-    def write_reporting_period(reporting_period, files_limit = MAX_FILES_LIMIT)
-      if at_layaway_file_limit?(files_limit)
-        ScoutApm::Agent.instance.logger.error("Hit layaway file limit. Not writing to layaway file")
-        return false
-      end
+    def write_reporting_period(reporting_period)
       filename = file_for(reporting_period.timestamp)
       layaway_file = LayawayFile.new(filename)
       layaway_file.write(reporting_period)
@@ -64,56 +56,41 @@ module ScoutApm
     def with_claim(timestamp)
       coordinator_file = glob_pattern(timestamp, :coordinator)
 
-      begin
-        # This file gets deleted only by a process that successfully created and obtained the exclusive lock
-        f = File.open(coordinator_file, File::RDWR | File::CREAT | File::EXCL | File::NONBLOCK)
-      rescue Errno::EEXIST
-        false
-      end
 
+      # This file gets deleted only by a process that successfully obtained a lock
+      f = File.open(coordinator_file, File::RDWR | File::CREAT)
       begin
-        if f
-          begin
-            ScoutApm::Agent.instance.logger.debug("Obtained Reporting Lock")
-
-            log_layaway_file_information
-
-            files = all_files_for(timestamp).reject{|l| l.to_s == coordinator_file.to_s }
-            rps = files.map{ |layaway| LayawayFile.new(layaway).load }.compact
-            if rps.any?
-              yield rps
-
-              ScoutApm::Agent.instance.logger.debug("Deleting the now-reported layaway files for #{timestamp.to_s}")
-              delete_files_for(timestamp) # also removes the coodinator_file
-
-              ScoutApm::Agent.instance.logger.debug("Checking for any Stale layaway files")
-              delete_stale_files(timestamp.to_time - STALE_AGE)
-            else
-              File.unlink(coordinator_file)
-              ScoutApm::Agent.instance.logger.debug("No layaway files to report")
-            end
-
-            true
-          rescue Exception => e
-            ScoutApm::Agent.instance.logger.debug("Caught an exception in with_claim, with the coordination file locked: #{e.message}, #{e.backtrace.inspect}")
-            raise
-          ensure
-            # Unlock the file when done!
-            f.flock(File::LOCK_UN | File::LOCK_NB)
-            f.close
+        # Nonblocking, Exclusive lock.
+        if f.flock(File::LOCK_EX | File::LOCK_NB)
+
+          ScoutApm::Agent.instance.logger.debug("Obtained Reporting Lock")
+
+          files = all_files_for(timestamp).reject{|l| l.to_s == coordinator_file.to_s }
+          rps = files.map{ |layaway| LayawayFile.new(layaway).load }.compact
+          if rps.any?
+            yield rps
+
+            delete_files_for(timestamp) # also removes the coodinator_file
+            delete_stale_files(timestamp.to_time - STALE_AGE)
+          else
+            File.unlink(coordinator_file)
+            ScoutApm::Agent.instance.logger.debug("No layaway files to report")
           end
+
+          # Unlock the file when done!
+          f.flock(File::LOCK_UN | File::LOCK_NB)
+          f.close
+          true
         else
           # Didn't obtain lock, another process is reporting. Return false from this function, but otherwise no work
+          f.close
           false
         end
       end
     end
 
     def delete_files_for(timestamp)
-      all_files_for(timestamp).each { |layaway|
-        ScoutApm::Agent.instance.logger.debug("Deleting layaway file: #{layaway}")
-        File.unlink(layaway)
-      }
+      all_files_for(timestamp).each { |layaway| File.unlink(layaway) }
     end
 
     def delete_stale_files(older_than)
@@ -124,8 +101,6 @@ module ScoutApm
         select { |timestamp| timestamp.to_i < older_than.strftime(TIME_FORMAT).to_i }.
           tap  { |timestamps| ScoutApm::Agent.instance.logger.debug("Deleting stale layaway files with timestamps: #{timestamps.inspect}") }.
         map    { |timestamp| delete_files_for(timestamp) }
-    rescue => e
-      ScoutApm::Agent.instance.logger.debug("Problem deleting stale files: #{e.message}, #{e.backtrace.inspect}")
     end
 
     private
@@ -176,24 +151,6 @@ module ScoutApm
         nil
       end
     end
-
-    def at_layaway_file_limit?(files_limit = MAX_FILES_LIMIT)
-      all_files_for(:all).count >= files_limit
-    end
-
-    def log_layaway_file_information
-      files_in_temp = Dir["#{directory}/*"].count
-
-      all_filenames = all_files_for(:all)
-      count_per_timestamp = Hash[
-        all_filenames.
-        group_by {|f| timestamp_from_filename(f) }.
-        map{ |timestamp, list| [timestamp, list.length] }
-      ]
-
-
-      ScoutApm::Agent.instance.logger.debug("Total in #{directory}: #{files_in_temp}. Total Layaway Files: #{all_filenames.size}.  By Timestamp: #{count_per_timestamp.inspect}")
-    end
   end
 end
 

data/lib/scout_apm/layer.rb

@@ -13,17 +13,13 @@ module ScoutApm
     #   instrumentation for an example of how this is useful
     attr_accessor :name
 
-    # An array of children layers
+    # An array of children layers, in call order.
     # For instance, if we are in a middleware, there will likely be only a single
     # child, which is another middleware.  In a Controller, we may have a handful
     # of children: [ActiveRecord, ActiveRecord, View, HTTP Call].
     #
     # This useful to get actual time spent in this layer vs. children time
-    #
-    # TODO: Check callers for compatibility w/ nil to avoid making an empty array
-    def children
-      @children || LayerChildrenSet.new
-    end
+    attr_reader :children
 
     # Time objects recording the start & stop times of this layer
     attr_reader :start_time, :stop_time
@@ -42,27 +38,41 @@ module ScoutApm
     # Known Keys:
     #   :record_count - The number of rows returned by an AR query (From notification instantiation.active_record)
     #   :class_name   - The ActiveRecord class name (From notification instantiation.active_record)
-    #
-    # If no annotations are ever set, this will return nil
     attr_reader :annotations
 
+    # ScoutProf - trace_index is an index into the Stack structure in the C
+    # code, used to store captured traces.
+    attr_reader :trace_index
+
+    # ScoutProf - frame_index is an optimization to not capture a few frames
+    # during scoutprof instrumentation
+    attr_reader :frame_index
+
+    # Captured backtraces from ScoutProf. This is distinct from the backtrace
+    # attribute, which gets the ruby backtrace of any given layer. StackProf
+    # focuses on Controller layers, and requires a native extension and a
+    # reasonably recent Ruby.
+    attr_reader :traces
+
     BACKTRACE_CALLER_LIMIT = 50 # maximum number of lines to send thru for backtrace analysis
 
     def initialize(type, name, start_time = Time.now)
       @type = type
       @name = name
+      @annotations = {}
       @start_time = start_time
       @allocations_start = ScoutApm::Instruments::Allocations.count
       @allocations_stop = 0
-
-      # initialize these only on first use
-      @children = nil
-      @annotations = nil
+      @children = [] # In order of calls
       @desc = nil
+
+      @traces = ScoutApm::TraceSet.new
+      @raw_frames = []
+      @frame_index = ScoutApm::Instruments::Stacks.current_frame_index # For efficiency sake, try to skip the bottom X frames when collecting traces
+      @trace_index = ScoutApm::Instruments::Stacks.current_trace_index
     end
 
     def add_child(child)
-      @children ||= LayerChildrenSet.new
       @children << child
     end
 
@@ -81,7 +91,6 @@ module ScoutApm
 
     # This data is internal to ScoutApm, to add custom information, use the Context api.
     def annotate_layer(hsh)
-      @annotations ||= {}
       @annotations.merge!(hsh)
     end
 
@@ -93,6 +102,14 @@ module ScoutApm
       @subscopable
     end
 
+    def traced!
+      @traced = true
+    end
+
+    def traced?
+      @traced
+    end
+
     # This is the old style name. This function is used for now, but should be
     # removed, and the new type & name split should be enforced through the
     # app.
@@ -114,6 +131,34 @@ module ScoutApm
       end
     end
 
+    # Set the name of the file that this action is coming from.
+    # TraceSet uses this to more accurately filter backtraces
+    def set_root_class(klass_name)
+      @traces.set_root_class(klass_name)
+    end
+
+    def start_sampling
+      if ScoutApm::Agent.instance.config.value('profile') && traced?
+        ScoutApm::Instruments::Stacks.update_indexes(frame_index, trace_index)
+        ScoutApm::Instruments::Stacks.start_sampling
+      else
+        ScoutApm::Instruments::Stacks.stop_sampling(false)
+      end
+    end
+
+    def record_traces!
+      if ScoutApm::Agent.instance.config.value('profile')
+        ScoutApm::Instruments::Stacks.stop_sampling(false)
+        if traced?
+          traces.raw_traces = ScoutApm::Instruments::Stacks.profile_frames
+          traces.skipped_in_gc = ScoutApm::Instruments::Stacks.skipped_in_gc
+          traces.skipped_in_handler = ScoutApm::Instruments::Stacks.skipped_in_handler
+          traces.skipped_in_job_registered = ScoutApm::Instruments::Stacks.skipped_in_job_registered
+        end
+      end
+    end
+
+
     ######################################
     # Debugging Helpers
     ######################################
@@ -154,7 +199,6 @@ module ScoutApm
         map { |child| child.total_call_time }.
         inject(0) { |sum, time| sum + time }
     end
-    private :child_time
 
     ######################################
     # Allocation Calculations
@@ -180,6 +224,5 @@ module ScoutApm
         map { |child| child.total_allocations }.
         inject(0) { |sum, obj| sum + obj }
     end
-    private :child_allocations
   end
 end

data/lib/scout_apm/layer_converters/converter_base.rb

@@ -1,7 +1,6 @@
 module ScoutApm
   module LayerConverters
     class ConverterBase
-
       attr_reader :walker
       attr_reader :request
       attr_reader :root_layer
@@ -9,10 +8,7 @@ module ScoutApm
       def initialize(request)
         @request = request
         @root_layer = request.root_layer
-        @backtraces = []
         @walker = DepthFirstWalker.new(root_layer)
-
-        @limited = false
       end
 
       # Scope is determined by the first Controller we hit.  Most of the time
@@ -31,201 +27,6 @@ module ScoutApm
           return layer if layer.type == layer_type
         end
       end
-
-      ################################################################################
-      # Subscoping
-      ################################################################################
-      #
-      # Keep a list of subscopes, but only ever use the front one.  The rest
-      # get pushed/popped in cases when we have many levels of subscopable
-      # layers.  This lets us push/pop without otherwise keeping track very closely.
-      def setup_subscopable_callbacks
-        @subscope_layers = []
-
-        walker.before do |layer|
-          if layer.subscopable?
-            @subscope_layers.push(layer)
-          end
-        end
-
-        walker.after do |layer|
-          if layer.subscopable?
-            @subscope_layers.pop
-          end
-        end
-      end
-
-      def subscoped?(layer)
-        @subscope_layers.first && layer != @subscope_layers.first # Don't scope under ourself.
-      end
-
-      def subscope_name
-        @subscope_layers.first.legacy_metric_name
-      end
-
-
-      ################################################################################
-      # Backtrace Handling
-      ################################################################################
-      #
-      # Because we get several layers for the same thing if you call an
-      # instrumented thing repeatedly, and only some of them may have
-      # backtraces captured, we store the backtraces off into another spot
-      # during processing, then at the end, we loop over those saved
-      # backtraces, putting them back into the metrics hash.
-      #
-      # This comes up most often when capturing n+1 backtraces. Because the
-      # query may be fast enough to evade our time-limit based backtrace
-      # capture, only the Nth item (see TrackedRequest for more detail) has a
-      # backtrack captured.  This sequence makes sure that we report up that
-      # backtrace in the aggregated set of metrics around that call.
-
-      # Call this as you are processing each layer. It will store off backtraces
-      def store_backtrace(layer, meta)
-        return unless layer.backtrace
-
-        bt = ScoutApm::Utils::BacktraceParser.new(layer.backtrace).call
-        if bt.any?
-          meta.backtrace = bt
-          @backtraces << meta
-        end
-      end
-
-      # Call this after you finish walking the layers, and want to take the
-      # set-aside backtraces and place them into the metas they match
-      def attach_backtraces(metric_hash)
-        @backtraces.each do |meta_with_backtrace|
-          metric_hash.keys.find { |k| k == meta_with_backtrace }.backtrace = meta_with_backtrace.backtrace
-        end
-        metric_hash
-      end
-
-
-      ################################################################################
-      # Limit Handling
-      ################################################################################
-
-      # To prevent huge traces from being generated, we should stop collecting
-      # detailed metrics as we go beyond some reasonably large count.
-      #
-      # We should still add up the /all aggregates.
-
-      MAX_METRICS = 500
-
-      def over_metric_limit?(metric_hash)
-        if metric_hash.size > MAX_METRICS
-          @limited = true
-        else
-          false
-        end
-      end
-
-      def limited?
-        !! @limited
-      end
-
-      ################################################################################
-      # Meta Scope
-      ################################################################################
-
-      # When we make MetricMeta records, we need to determine a few things from layer.
-      def make_meta_options(layer)
-        scope_hash = make_meta_options_scope(layer)
-        desc_hash = make_meta_options_desc_hash(layer)
-
-        scope_hash.merge(desc_hash)
-      end
-
-      def make_meta_options_scope(layer)
-        # This layer is scoped under another thing. Typically that means this is a layer under a view.
-        # Like: Controller -> View/users/show -> ActiveRecord/user/find
-        #   in that example, the scope is the View/users/show
-        if subscoped?(layer)
-          {:scope => subscope_name}
-
-        # We don't scope the controller under itself
-        elsif layer == scope_layer
-          {}
-
-        # This layer is a top level metric ("ActiveRecord", or "HTTP" or
-        # whatever, directly under the controller), so scope to the
-        # Controller
-        else
-          {:scope => scope_layer.legacy_metric_name}
-        end
-      end
-
-      def make_meta_options_desc_hash(layer, max_desc_length=1000)
-        if layer.desc
-          desc_s = layer.desc.to_s
-          trimmed_desc = desc_s[0 .. max_desc_length]
-          {:desc => trimmed_desc}
-        else
-          {}
-        end
-      end
-
-
-      ################################################################################
-      # Storing metrics into the hashes
-      ################################################################################
-
-      # This is the detailed metric - type, name, backtrace, annotations, etc.
-      def store_specific_metric(layer, metric_hash, allocation_metric_hash)
-        return false if over_metric_limit?(metric_hash)
-
-        meta_options = make_meta_options(layer)
-
-        meta = MetricMeta.new(layer.legacy_metric_name, meta_options)
-        meta.extra.merge!(layer.annotations) if layer.annotations
-
-        store_backtrace(layer, meta)
-
-        metric_hash[meta] ||= MetricStats.new(meta_options.has_key?(:scope))
-        allocation_metric_hash[meta] ||= MetricStats.new(meta_options.has_key?(:scope))
-
-        # timing
-        stat = metric_hash[meta]
-        stat.update!(layer.total_call_time, layer.total_exclusive_time)
-
-        # allocations
-        stat = allocation_metric_hash[meta]
-        stat.update!(layer.total_allocations, layer.total_exclusive_allocations)
-
-        if LimitedLayer === layer
-          metric_hash[meta].call_count = layer.count
-          allocation_metric_hash[meta].call_count = layer.count
-        end
-      end
-
-      # Merged Metric - no specifics, just sum up by type (ActiveRecord, View, HTTP, etc)
-      def store_aggregate_metric(layer, metric_hash, allocation_metric_hash)
-          meta = MetricMeta.new("#{layer.type}/all")
-
-          metric_hash[meta] ||= MetricStats.new(false)
-          allocation_metric_hash[meta] ||= MetricStats.new(false)
-
-          # timing
-          stat = metric_hash[meta]
-          stat.update!(layer.total_call_time, layer.total_exclusive_time)
-
-          # allocations
-          stat = allocation_metric_hash[meta]
-          stat.update!(layer.total_allocations, layer.total_exclusive_allocations)
-      end
-
-      ################################################################################
-      # Misc Helpers
-      ################################################################################
-
-      # Sometimes we start capturing a layer without knowing if we really
-      # want to make an entry for it.  See ActiveRecord instrumentation for
-      # an example. We start capturing before we know if a query is cached
-      # or not, and want to skip any cached queries.
-      def skip_layer?(layer)
-        return false if layer.annotations.nil?
-        return true  if layer.annotations[:ignorable]
-      end
     end
   end
 end