scout_apm 3.0.0.pre28 → 4.0.0

data/lib/scout_apm/slow_job_policy.rb

@@ -1,111 +0,0 @@
-# Long running class that determines if, and in how much detail a potentially
-# slow job should be recorded in
-
-module ScoutApm
-  class SlowJobPolicy
-    CAPTURE_TYPES = [
-      CAPTURE_DETAIL  = "capture_detail",
-      CAPTURE_NONE    = "capture_none",
-    ]
-
-    # Adjust speed points. See the function
-    POINT_MULTIPLIER_SPEED = 0.25
-
-    # For each minute we haven't seen an endpoint
-    POINT_MULTIPLIER_AGE = 0.25
-
-    # Outliers are worth up to "1000ms" of weight
-    POINT_MULTIPLIER_PERCENTILE = 1.0
-
-    # Points for an endpoint's who's throughput * response time is a large % of
-    # overall time spent processing requests
-    POINT_MULTIPLIER_PERCENT_TIME = 2.5
-
-    # A hash of Job Names to the last time we stored a slow trace for it.
-    #
-    # Defaults to a start time that is pretty close to application boot time.
-    # So the "age" of an endpoint we've never seen is the time the application
-    # has been running.
-    attr_reader :last_seen
-
-    # The AgentContext we're running in
-    attr_reader :context
-
-    def initialize(context)
-      @context = context
-
-      zero_time = Time.now
-      @last_seen = Hash.new { |h, k| h[k] = zero_time }
-    end
-
-    def stored!(request)
-      last_seen[request.unique_name] = Time.now
-    end
-
-    # Determine if this job trace should be fully analyzed by scoring it
-    # across several metrics, and then determining if that's good enough to
-    # make it into this minute's payload.
-    #
-    # Due to the combining nature of the agent & layaway file, there's no
-    # guarantee that a high scoring local champion will still be a winner when
-    # they go up to "regionals" and are compared against the other processes
-    # running on a node.
-    def score(request)
-      unique_name = request.unique_name
-      if unique_name == :unknown
-        return -1 # A negative score, should never be good enough to store.
-      end
-
-      total_time = request.root_layer.total_call_time
-
-      # How long has it been since we've seen this?
-      age = Time.now - last_seen[unique_name]
-
-      # What approximate percentile was this request?
-      percentile = context.request_histograms.approximate_quantile_of_value(unique_name, total_time)
-
-      percent_of_total_time = context.transaction_time_consumed.percent_of_total(unique_name)
-
-      return speed_points(total_time) + percentile_points(percentile) + age_points(age) + percent_time_points(percent_of_total_time)
-    end
-
-    private
-
-    # Time in seconds
-    # Logarithm keeps huge times from swamping the other metrics.
-    # 1+ is necessary to keep the log function in positive territory.
-    def speed_points(time)
-      Math.log(1 + time) * POINT_MULTIPLIER_SPEED
-    end
-
-    def percentile_points(percentile)
-      if percentile < 40
-        0.4 # Don't put much emphasis on capturing low percentiles.
-      elsif percentile < 60
-        1.4 # Highest here to get mean traces
-      elsif percentile < 90
-        0.7 # Between 60 & 90% is fine.
-      elsif percentile >= 90
-        1.4 # Highest here to get 90+%ile traces
-      else
-        # impossible.
-        percentile
-      end
-    end
-
-    def age_points(age)
-      age / 60.0 * POINT_MULTIPLIER_AGE
-    end
-
-    # Of the total time spent handling endpoints in this app, if this endpoint
-    # is a higher percent, it should get more points.
-    #
-    # A: 20 calls @ 100ms each => 2 seconds of total time
-    # B: 10 calls @ 100ms each => 1 second of total time
-    #
-    # Then A is 66% of the total call time
-    def percent_time_points(percent) # Scale 0.0 - 1.0
-      percent * POINT_MULTIPLIER_PERCENT_TIME
-    end
-  end
-end

data/lib/scout_apm/trace_compactor.rb

@@ -1,312 +0,0 @@
-# Takes in a ton of traces. Structure is a several nested arrays:
-# [                             # Traces
-#    [                          # Trace
-#      [file,line,method,klass] # TraceLine (raw)
-#    ]
-# ]
-#
-# Cleans them
-# Merges them by gem/app
-#
-module ScoutApm
-class TraceSet
-  # A TraceCube object which is a glorified hash of { Trace -> Count }. Used to
-  # collect up the count of each unique trace we've seen
-  attr_reader :cube
-
-  # Allow layer to push values in
-  attr_accessor :raw_traces
-  attr_accessor :skipped_in_gc
-  attr_accessor :skipped_in_handler
-  attr_accessor :skipped_in_job_registered
-  attr_accessor :skipped_in_not_running
-
-  def initialize
-    @raw_traces = []
-    @cube = TraceCube.new
-  end
-
-  # We need to know what the "Start" of this trace is.  An untrimmed trace generally is:
-  #
-  # Gem
-  # Gem
-  # App
-  # App
-  # App <---- set root_class of this.
-  # Rails
-  # Rails
-  def set_root_class(klass_name)
-    @root_klass = klass_name.to_s
-  end
-
-  def to_a
-    res = []
-    create_cube!
-    @cube.each do |(trace, count)|
-      res << [trace.to_a, count]
-    end
-
-    res
-  end
-
-  def as_json
-    res = []
-    create_cube!
-    @cube.each do |(trace, count)|
-      res << [trace.as_json, count]
-    end
-
-    res
-  end
-
-  def create_cube!
-    while raw_trace = @raw_traces.shift
-      clean_trace = ScoutApm::CleanTrace.new(raw_trace, @root_klass)
-      @cube << clean_trace
-    end
-    @raw_traces = []
-  end
-
-  def total_count
-    create_cube!
-    cube.inject(0) do |sum, (_, count)|
-      sum + count
-    end
-  end
-
-  def inspect
-    create_cube!
-    cube.map do |(trace, count)|
-      "\t#{count} -- #{trace.first.klass}##{trace.first.method}\n\t\t#{trace.to_a[1].try(:klass)}##{trace.to_a[1].try(:method)}"
-    end.join("\n")
-  end
-end
-
-# A trace is a list of individual lines, where one called another, forming a backtrace.
-# Each line is made up of File, Line #, Klass, Method
-#
-# For the purpouses of this class:
-#   "Top" of the trace means the currently-running method.
-#   "Bottom" means the root of the call tree, from program start into rails and so on.
-#
-# This class trims off top and bottom to get a the meat of the trace
-class CleanTrace
-  include Enumerable
-
-  attr_reader :lines
-
-  def initialize(raw_trace, root_klass=nil)
-    @lines = Array(raw_trace).map {|frame, lineno| TraceLine.new(frame, lineno)}
-    @root_klass = root_klass
-
-    # A trace has interesting data in the middle of it, since normally it'll go
-    # RailsCode -> App Code -> Gem Code.
-    #
-    # So we drop the code that leads up to your app, since a deep trace that
-    # always says that you went through middleware and the rails router doesn't
-    # help diagnose issues.
-    drop_below_app
-
-    # Then we drop most of the Gem Code, since you didn't write it, and in the
-    # vast majority of the cases, the time spent there is because your app code
-    # asked, not because of inherent issues with the gem. For instance, if you
-    # fire off a slow query to a database gem, you probably want to be
-    # optimizing the query, not trying to make the database gem faster.
-    drop_above_app
-  end
-
-  # Iterate starting at END of array until a controller line is found. Pop off at that index - 1.
-  def drop_below_app
-    pops = 0
-    index = lines.size - 1 # last index, not size.
-
-    while index >= 0 && !lines[index].controller?(@root_klass)
-      index -= 1
-      pops += 1
-    end
-
-    lines.pop(pops)
-  end
-
-  # Find the closest mention of the application code from the currently-running method.
-  # Then adjust by 1 if possible to capture the "first" line 
-  def drop_above_app
-    ai = @lines.find_index(&:app?)
-    if ai
-      ai -= 1 if ai > 0
-      @lines = @lines[ai .. -1]
-    else
-      @lines = [] # No app line in backtrace, nothing to show?
-    end
-  end
-
-  def each
-    @lines.each { |line| yield line }
-  end
-
-  def empty?
-    @lines.empty?
-  end
-
-  def as_json
-    @lines.map { |line| line.as_json }
-  end
-
-  ###############################
-  # Hash Key interface
-  def hash
-    @lines.hash
-  end
-
-  def eql?(other)
-    @lines.eql?(other.lines)
-  end
-  ###############################
-end
-
-class TraceLine
-  # An opaque C object, only call Stacks#frame_* methods on this.
-  attr_reader :frame
-
-  # The line number. This doesn't appear to be obtainable from the frame itself
-  attr_reader :lineno
-
-  def initialize(frame, lineno)
-    @frame = frame
-    @lineno = lineno
-  end
-
-  # Returns the name of the last gem in the line
-  def gem_name
-    @gem_name ||= begin
-                    r = %r{\/gems/(.*?)/}.freeze
-                    results = file.scan(r)
-                    results[-1][0] # Scan will return a nested array, so extract out that nesting
-                  rescue
-                    nil
-                  end
-  end
-
-  def stdlib_name
-    @stdlib_name ||= begin
-                    r = %r{#{Regexp.escape(RbConfig::TOPDIR)}/(.*?)}.freeze
-                    results = file.scan(r)
-                    results[-1][0] # Scan will return a nested array, so extract out that nesting
-                  rescue
-                    nil
-                  end
-  end
-
-  def file
-    ScoutApm::Instruments::Stacks.frame_file(frame)
-  end
-
-
-  # If we ever want to get the "first line of the method" - ScoutApm::Instruments::Stacks.frame_lineno(frame)
-  def line
-    lineno
-  end
-
-  def klass
-    ScoutApm::Instruments::Stacks.frame_klass(frame)
-  end
-
-  def method
-    ScoutApm::Instruments::Stacks.frame_method(frame)
-  end
-
-  def gem?
-    !!gem_name
-  end
-
-  def stdlib?
-    !!stdlib_name
-  end
-
-  def app?
-    r = %r|^#{Regexp.escape(ScoutApm::Environment.instance.root.to_s)}/|.freeze
-    result = !gem_name && !stdlib_name && file =~ r
-    !!result # coerce to a bool
-  end
-
-  def trim_file(file_path)
-    return if file_path.nil?
-    if gem?
-      r = %r{.*gems/.*?/}.freeze
-      file_path.sub(r, "/")
-    elsif stdlib?
-      file_path.sub(RbConfig::TOPDIR, '')
-    elsif app?
-      file_path.sub(ScoutApm::Environment.instance.root.to_s, '')
-    end
-  end
-
-  # If root_klass is provided, just see if this is exactly that class. If not,
-  # fall back on "is this in the app"
-  def controller?(root_klass)
-    return false if klass.nil? # main function doesn't have a file associated
-
-    if root_klass
-      klass == root_klass
-    else
-      app?
-    end
-  end
-
-  def formatted_to_s
-    "#{stdlib_name} #{klass}##{method} -- #{file}:#{line}"
-  end
-
-  def as_json
-    [ trim_file(file), line, klass, method, app?, gem_name, stdlib_name ]
-  end
-
-  ###############################
-  # Hash Key interface
-
-  def hash
-    # Note that this does not include line number. It caused a few situations
-    # where we had a bunch of time spent in one method, but across a few lines,
-    # we decided that it made sense to group them together.
-    file.hash ^ method.hash ^ klass.hash
-  end
-
-  def eql?(other)
-    file == other.file &&
-      method == other.method &&
-      klass == other.klass
-  end
-
-  ###############################
-end
-
-# Collects clean traces and counts how many of each we have.
-class TraceCube
-  include Enumerable
-
-  attr_reader :traces
-  attr_reader :total_count
-
-  def initialize
-    @traces = Hash.new{ |h,k| h[k] = 0 }
-    @total_count = 0
-  end
-
-  def <<(clean_trace)
-    @total_count += 1
-    @traces[clean_trace] += 1
-  end
-
-  # Yields two element array, the trace and the count of that trace
-  # In descending order of count.
-  def each
-    @traces
-      .to_a
-      .each { |(trace, count)|
-        next if trace.empty?
-        yield [trace, count]
-      }
-  end
-end
-end
-

data/lib/scout_apm/utils/fake_stacks.rb

@@ -1,88 +0,0 @@
-# A fake implementation of the allocations native extension, for systems that don't support it.
-module ScoutApm
-  module Instruments
-    class Stacks
-      ENABLED = false
-      INSTALLED = false
-
-      class << self
-        def install(*args)
-          # noop
-        end
-
-        def uninstall(*args)
-          # noop
-        end
-
-        def start(*args)
-          # noop
-        end
-
-        def add_profiled_thread(*args)
-          # noop
-        end
-
-        def remove_profiled_thread(*args)
-          # noop
-        end
-
-        def profile_frames(*args)
-          [] # frames that were profiled (none)
-        end
-
-        def start_sampling(*args)
-          # noop
-        end
-
-        def stop_sampling(*args)
-          # noop
-        end
-
-        def update_indexes(*args)
-          # noop
-          true
-        end
-
-        def current_trace_index(*args)
-          :opaque_value
-        end
-
-        def current_frame_index(*args)
-          :opaque_value
-        end
-
-        def frame_klass(*args)
-          nil
-        end
-
-        def frame_method(*args)
-          nil
-        end
-
-        def frame_file(*args)
-          nil
-        end
-
-        def frame_lineno(*args)
-          nil
-        end
-
-        def skipped_in_gc(*args)
-          0
-        end
-
-        def skipped_in_handler(*args)
-          0
-        end
-
-        def skipped_in_job_registered(*args)
-          0
-        end
-
-        def skipped_in_not_running(*args)
-          0
-        end
-      end
-    end
-  end
-end