scout_apm 2.1.32 → 2.2.0.pre0

data/lib/scout_apm/tracked_request.rb

@@ -42,47 +42,35 @@ module ScoutApm
     # 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)
       @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
+      @ignoring_children = false
       @context = Context.new
       @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
-
-      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
+      @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.
@@ -90,16 +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!
 
-      @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)
@@ -109,6 +96,8 @@ module ScoutApm
 
       if finalized?
         stop_request
+      else
+        continue_sampling_for_layers if ScoutApm::Agent.instance.config.value('profile')
       end
     end
 
@@ -126,8 +115,6 @@ module ScoutApm
 
     BACKTRACE_BLACKLIST = ["Controller", "Job"]
     def capture_backtrace?(layer)
-      return if ignoring_request?
-
       # Never capture backtraces for this kind of layer. The backtrace will
       # always be 100% framework code.
       return false if BACKTRACE_BLACKLIST.include?(layer.type)
@@ -171,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
@@ -182,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
+
+    # Enable ScoutProf for this thread
+    def enable_profiled_thread!
+        ScoutApm::Instruments::Stacks.add_profiled_thread
     end
 
-    def stopping?
-      @stopping
+    # Disable ScoutProf for this thread
+    def disable_profiled_thread!
+        ScoutApm::Instruments::Stacks.remove_profiled_thread
     end
 
     ###################################
@@ -236,8 +236,6 @@ module ScoutApm
     end
 
     def instant?
-      return false if ignoring_request?
-
       instant_key
     end
 
@@ -245,20 +243,10 @@ 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_store if @store.nil?
+      @recorded = true
 
       # Bail out early if the user asked us to ignore this uri
       return if ScoutApm::Agent.instance.ignored_uris.ignore?(annotations[:uri])
@@ -290,7 +278,7 @@ module ScoutApm
         # 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
+          ScoutApm::InstantReporting.new(trace, instant_key).call()
         end
       end
 
@@ -304,12 +292,11 @@ module ScoutApm
 
       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::ConverterBase.new(self).scope_layer
                          if scope_layer
@@ -324,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
 
@@ -338,36 +323,21 @@ module ScoutApm
     # specific, and useful than the fact that InfluxDB happens to use Net::HTTP
     # internally
     #
-    # When enabled, new layers won't be added to the current Request, and calls
-    # to stop_layer will be ignored.
+    # When enabled, new layers won't be added to the current Request.
     #
     # Do not forget to turn if off when leaving a layer, it is the
     # instrumentation's task to do that.
-    #
-    # When you use this in code, be sure to use it in this order:
-    #
-    # start_layer
-    # ignore_children
-    #  -> call
-    # acknowledge_children
-    # stop_layer
-    #
-    # If you don't call it in this order, it's possible to get out of sync, and
-    # have an ignored start and an actually-executed stop, causing layers to
-    # get out of sync
 
     def ignore_children!
-      @ignoring_children += 1
+      @ignoring_children = true
     end
 
     def acknowledge_children!
-      if @ignoring_children > 0
-        @ignoring_children -= 1
-      end
+      @ignoring_children = false
     end
 
     def ignoring_children?
-      @ignoring_children > 0
+      @ignoring_children
     end
 
     # Grab backtraces more aggressively when running in dev trace mode
@@ -375,66 +345,5 @@ module ScoutApm
       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
-    ################################################################################
-
-    # 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.
-
-    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
-      ScoutApm::Agent.instance.logger
-    end
-
-    # 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
-    end
-
-    # 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
-    end
   end
 end

data/lib/scout_apm/utils/backtrace_parser.rb

@@ -6,30 +6,28 @@ 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
 
       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
-        #
-        # This regex looks for files under the app root, inside lib/, app/, and
-        # config/ dirs, and captures the path under root.
-        @@app_dir_regex = %r[#{root}/((?:lib/|app/|config/).*)]
+        @@app_dir_regex = %r|#{root}/(.*)|
       end
 
       def call
         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
         stack
       end
+
     end
   end
 end

data/lib/scout_apm/utils/fake_stacks.rb

@@ -0,0 +1,83 @@
+# A fake implementation of the allocations native extension, for systems that don't support it.
+module ScoutApm
+  module Instruments
+    class Stacks
+      ENABLED = 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
+      end
+    end
+  end
+end

data/lib/scout_apm/version.rb

@@ -1,4 +1,4 @@
 module ScoutApm
-  VERSION = "2.1.32"
+  VERSION = "2.2.0.pre0"
 end
 

data/scout_apm.gemspec

@@ -19,15 +19,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib","data"]
   s.extensions << 'ext/allocations/extconf.rb'
-  s.extensions << 'ext/rusage/extconf.rb'
+  s.extensions << 'ext/stacks/extconf.rb'
+
+  s.add_runtime_dependency "rusage", '~> 0.2.0'
 
   s.add_development_dependency "minitest"
-  s.add_development_dependency 'mocha'
   s.add_development_dependency "pry"
   s.add_development_dependency "m"
   s.add_development_dependency "simplecov"
   s.add_development_dependency "rake-compiler"
-  s.add_development_dependency "addressable"
-  s.add_development_dependency "guard"
-  s.add_development_dependency "guard-minitest"
-end
+end

data/test/test_helper.rb

@@ -5,7 +5,6 @@ SimpleCov.start
 require 'minitest/autorun'
 require 'minitest/unit'
 require 'minitest/pride'
-require 'mocha/mini_test'
 require 'pry'
 
 
@@ -16,44 +15,8 @@ Kernel.module_eval do
   def self.const_unset(const)
     self.instance_eval { remove_const(const) }
   end
-
-  def silence_warnings(&block)
-    warn_level = $VERBOSE
-    $VERBOSE = nil
-    result = block.call
-    $VERBOSE = warn_level
-    result
-  end
-end
-
-# A test helper class to create a temporary "configuration" we can control entirely purposes
-class FakeConfigOverlay
-  def initialize(values)
-    @values = values
-  end
-
-  def value(key)
-    @values[key]
-  end
-
-  def has_key?(key)
-    @values.has_key?(key)
-  end
 end
 
-class FakeEnvironment
-  def initialize(values)
-    @values = values
-  end
-
-  def method_missing(sym)
-    if @values.has_key?(sym)
-      @values[sym]
-    else
-      raise "#{sym} not found in FakeEnvironment"
-    end
-  end
-end
 
 # Helpers available to all tests
 class Minitest::Test
@@ -79,25 +42,6 @@ class Minitest::Test
     ScoutApm::Agent.instance.instance_variable_set("@logger", @logger)
   end
 
-  def make_fake_environment(values)
-    FakeEnvironment.new(values)
-  end
-
-  def make_fake_config(values)
-    ScoutApm::Config.new(FakeConfigOverlay.new(values))
-  end
-
   DATA_FILE_DIR = File.dirname(__FILE__) + '/tmp'
   DATA_FILE_PATH = "#{DATA_FILE_DIR}/scout_apm.db"
 end
-
-
-module CustomAsserts
-  def assert_false(thing)
-    assert !thing
-  end
-end
-
-class Minitest::Test
-  include CustomAsserts
-end