scout_apm 3.0.0.pre3 → 3.0.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3721ca109f1e1cb44b9b3f06ee32eda61f77a67d
-  data.tar.gz: 19f4934a1cf694a233cc23f577fab0b10cffdcd9
+  metadata.gz: 65e71c8c9518a483f581e8c903ce36fa216fd964
+  data.tar.gz: 693bab7ca8a2189697b0802e2919ce9ebf6a81e8
 SHA512:
-  metadata.gz: 447e27d5da749e8b58c71db8288c94f9e74cc1bd357282396ee7cfc3f93b8db63af23f79f4af35cbdf70c3d59715a9be2c1a43c12b4566335c234c11fe4b3c59
-  data.tar.gz: 3f082fd12f47d360c91ba9d0f743e4628a19cf9009edff49ed0570923a8b6ece527dedc327b2d7cd339df4fad18ba77f8022a552cde20df2600b4fa7419c8d52
+  metadata.gz: a6050bfc0ea85e521707640550eee61cb147f395e7b6610abb1774faf2bdf2009557c93057e886c65f565192c7a46aa5b0ef54b315c8d8711f62d91bb5905157
+  data.tar.gz: d9a50a872883792a85e8cbe7987a4f9e2ace192b09b9474c388d42bb204869f326e8f46bedd41078d0505b1c7d3d0fc40a1dc9ab9fd243743e44e5af61eaa17e

data/CHANGELOG.markdown

@@ -6,6 +6,28 @@
 
 * ScoutProf BETA
 
+# 2.1.15
+
+* Limit memory usage for very long running requests.
+
+# 2.1.14
+
+* Add TrackedRequest#ignore_request! to entirely ignore and stop capturing a
+  certain request. Use in your code by calling:
+    ScoutApm::RequestManager.lookup.ignore_request!
+
+# 2.1.13
+
+* Rework Delayed Job instrumentation to not interfere with other instruments.
+
+# 2.1.12
+
+* Revert 2.1.11's Delayed Job change - caused issues in a handful of environments
+
+# 2.1.11
+
+* Support alternate methods of launching Delayed Job
+
 # 2.1.10
 
 * Fix issue getting a default Application Name when it wasn't explicitly set

data/lib/scout_apm/agent.rb

@@ -281,20 +281,13 @@ module ScoutApm
 
     # Loads the instrumention logic.
     def load_instruments
-      if !background_job_missing?
-#        case environment.background_job_name
-#        when :delayed_job
-#          install_instrument(ScoutApm::Instruments::DelayedJob)
-#        end
-      else
-        case environment.framework
-        when :rails       then install_instrument(ScoutApm::Instruments::ActionControllerRails2)
-        when :rails3_or_4 then
-          install_instrument(ScoutApm::Instruments::ActionControllerRails3Rails4)
-          install_instrument(ScoutApm::Instruments::MiddlewareSummary)
-          install_instrument(ScoutApm::Instruments::RailsRouter)
-        # when :sinatra     then install_instrument(ScoutApm::Instruments::Sinatra)
-        end
+      case environment.framework
+      when :rails then
+        install_instrument(ScoutApm::Instruments::ActionControllerRails2)
+      when :rails3_or_4 then
+        install_instrument(ScoutApm::Instruments::ActionControllerRails3Rails4)
+        install_instrument(ScoutApm::Instruments::MiddlewareSummary)
+        install_instrument(ScoutApm::Instruments::RailsRouter)
       end
 
       install_instrument(ScoutApm::Instruments::ActiveRecord)

data/lib/scout_apm/background_job_integrations/delayed_job.rb

@@ -8,7 +8,7 @@ module ScoutApm
       end
 
       def present?
-        defined?(::Delayed::Job) && File.basename($PROGRAM_NAME).start_with?('delayed_job')
+        defined?(::Delayed::Job)
       end
 
       def forking?

data/lib/scout_apm/instant/middleware.rb

@@ -50,6 +50,9 @@ module ScoutApm
         if ScoutApm::Agent.instance.config.value('dev_trace')
           if response.respond_to?(:body)
             req = ScoutApm::RequestManager.lookup
+
+            return [status, headers, response] if req.ignoring_request?
+
             slow_converter = LayerConverters::SlowRequestConverter.new(req)
             trace = slow_converter.call
             if trace

data/lib/scout_apm/instruments/active_record.rb

@@ -62,8 +62,10 @@ module ScoutApm
             layer = req.current_layer
             if layer && layer.type == "ActiveRecord"
               layer.annotate_layer(payload)
-            else
+            elsif layer
               ScoutApm::Agent.instance.logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
+            else
+              # noop, no layer at all. We're probably ignoring this req.
             end
           end
         end

data/lib/scout_apm/instruments/net_http.rb

@@ -22,12 +22,17 @@ module ScoutApm
             include ScoutApm::Tracer
 
             def request_with_scout_instruments(*args,&block)
-              url = (@address + args.first.path.split('?').first)[0..99]
-              self.class.instrument("HTTP", "request", :desc => url) do
+              self.class.instrument("HTTP", "request", :desc => request_scout_description(args.first)) do
                 request_without_scout_instruments(*args, &block)
               end
             end
 
+            def request_scout_description(req)
+              path = req.path
+              path = path.path if path.respond_to?(:path)
+              (@address + path.split('?').first)[0..99]
+            end
+
             alias request_without_scout_instruments request
             alias request request_with_scout_instruments
           end

data/lib/scout_apm/layer.rb

@@ -13,13 +13,17 @@ module ScoutApm
     #   instrumentation for an example of how this is useful
     attr_accessor :name
 
-    # An array of children layers, in call order.
+    # An array of children layers
     # 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
-    attr_reader :children
+    #
+    # TODO: Check callers for compatibility w/ nil to avoid making an empty array
+    def children
+      @children || LayerChildrenSet.new
+    end
 
     # Time objects recording the start & stop times of this layer
     attr_reader :start_time, :stop_time
@@ -38,6 +42,8 @@ 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
@@ -59,11 +65,13 @@ module ScoutApm
     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
-      @children = [] # In order of calls
+
+      # initialize these only on first use
+      @children = nil
+      @annotations = nil
       @desc = nil
 
       @traces = ScoutApm::TraceSet.new
@@ -73,6 +81,7 @@ module ScoutApm
     end
 
     def add_child(child)
+      @children ||= LayerChildrenSet.new
       @children << child
     end
 
@@ -91,6 +100,7 @@ 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
 
@@ -200,6 +210,7 @@ module ScoutApm
         map { |child| child.total_call_time }.
         inject(0) { |sum, time| sum + time }
     end
+    private :child_time
 
     ######################################
     # Allocation Calculations
@@ -225,5 +236,6 @@ module ScoutApm
         map { |child| child.total_allocations }.
         inject(0) { |sum, obj| sum + obj }
     end
+    private :child_allocations
   end
 end

data/lib/scout_apm/layer_children_set.rb

@@ -0,0 +1,72 @@
+module ScoutApm
+  # A set of children records for any given Layer.  This implements some
+  # rate-limiting logic.
+  #
+  # We store the first `unique_cutoff` count of each layer type. So if cutoff
+  # is 1000, we'd store 1000 HTTP layers, and 1000 ActiveRecord calls, and 1000
+  # of each other layer type. After that, make a LimitedLayer object and store
+  # only aggregate counts and times of future layers of that type. (So the
+  # 1001st an onward of ActiveRecord would get only aggregate times, and
+  # counts, without any detail about the SQL called)
+  #
+  # When the set of children is small, keep them unique
+  # When the set of children gets large enough, stop keeping details
+  #
+  # The next optimization, which is not yet implemented:
+  #   when the set of children gets larger, attempt to merge them without data loss
+  class LayerChildrenSet
+    include Enumerable
+
+    # By default, how many unique children of a type do we store before
+    # flipping over to storing only aggregate info.
+    DEFAULT_UNIQUE_CUTOFF = 2000
+    attr_reader :unique_cutoff
+
+    # The Set of children objects
+    attr_reader :children
+    private :children
+
+    def initialize(unique_cutoff = DEFAULT_UNIQUE_CUTOFF)
+      @children = Hash.new { |hash, key| hash[key] = Set.new }
+      @limited_layers = nil # populated when needed
+      @unique_cutoff = unique_cutoff
+    end
+
+    # Add a new layer into this set
+    # Only add completed layers - otherwise this will collect up incorrect info
+    # into the created LimitedLayer, since it will "freeze" any current data for
+    # total_call_time and similar methods.
+    def <<(child)
+      metric_type = child.type
+      set = children[metric_type]
+
+      if set.size >= unique_cutoff
+        # find limited_layer
+        @limited_layers || init_limited_layers
+        @limited_layers[metric_type].absorb(child)
+      else
+        # we have space just add it
+        set << child
+      end
+    end
+
+    def each
+      children.each do |_type, set|
+        set.each do |child_layer|
+          yield child_layer
+        end
+      end
+
+      if @limited_layers
+        @limited_layers.each do |_type, limited_layer|
+          yield limited_layer
+        end
+      end
+    end
+
+    # hold off initializing this until we know we need it
+    def init_limited_layers
+      @limited_layers ||= Hash.new { |hash, key| hash[key] = LimitedLayer.new(key) }
+    end
+  end
+end

data/lib/scout_apm/layer_converters/converter_base.rb

@@ -177,7 +177,7 @@ module ScoutApm
         meta_options = make_meta_options(layer)
 
         meta = MetricMeta.new(layer.legacy_metric_name, meta_options)
-        meta.extra.merge!(layer.annotations)
+        meta.extra.merge!(layer.annotations) if layer.annotations
 
         store_backtrace(layer, meta)
 
@@ -187,13 +187,16 @@ module ScoutApm
         # Timing
         timing_stat = metric_hash[meta]
         timing_stat.update!(layer.total_call_time, layer.total_exclusive_time)
+        timing_stat.add_traces(layer.traces.as_json)
 
         # Allocations
         allocation_stat = allocation_metric_hash[meta]
         allocation_stat.update!(layer.total_allocations, layer.total_exclusive_allocations)
 
-        # Attach Scoutprof Traces
-        timing_stat.add_traces(layer.traces.as_json)
+        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)
@@ -221,7 +224,8 @@ module ScoutApm
       # 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 true if layer.annotations[:ignorable]
+        return false if layer.annotations.nil?
+        return true  if layer.annotations[:ignorable]
       end
 
       # Debug logging for scoutprof traces

data/lib/scout_apm/layer_converters/job_converter.rb

@@ -57,7 +57,7 @@ module ScoutApm
         walker.walk do |layer|
           next if layer == job_layer
           next if layer == queue_layer
-          next if layer.annotations[:ignorable]
+          next if skip_layer?(layer)
 
           # we don't need to use the full metric name for scoped metrics as we
           # only display metrics aggregrated by type, just use "ActiveRecord"

data/lib/scout_apm/layer_converters/metric_converter.rb

@@ -21,7 +21,7 @@ module ScoutApm
         metric_hash = Hash.new
 
         walker.walk do |layer|
-          next if layer.annotations[:ignorable]
+          next if skip_layer?(layer)
 
           meta_options = if layer == scope_layer # We don't scope the controller under itself
                           {}

data/lib/scout_apm/limited_layer.rb

@@ -0,0 +1,129 @@
+module ScoutApm
+  # A LimitedLayer is a lossy-compression approach to fall back on once we max out
+  # the number of detailed layer objects we store.  See LayerChildrenSet for the
+  # logic on when that change over happens
+  #
+  # QUESTION: What do we do if we attempt to merge an item that has children?
+  class LimitedLayer
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+
+      @total_call_time = 0
+      @total_exclusive_time = 0
+      @total_allocations = 0
+      @total_exclusive_allocations = 0
+      @total_layers = 0
+    end
+
+    def absorb(layer)
+      @total_layers += 1
+
+      @total_call_time += layer.total_call_time
+      @total_exclusive_time += layer.total_exclusive_time
+
+      @total_allocations += layer.total_allocations
+      @total_exclusive_allocations += layer.total_exclusive_allocations
+    end
+
+    def total_call_time
+      @total_call_time
+    end
+
+    def total_exclusive_time
+      @total_exclusive_time
+    end
+
+    def total_allocations
+      @total_allocations
+    end
+
+    def total_exclusive_allocations
+      @total_exclusive_allocations
+    end
+
+    def count
+      @total_layers
+    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.
+    def legacy_metric_name
+      "#{type}/Limited"
+    end
+
+    def children
+      Set.new
+    end
+
+    def annotations
+      nil
+    end
+
+    def to_s
+      "<LimitedLayer type=#{type} count=#{count}>"
+    end
+
+    ######################################################
+    #  Stub out some methods with static default values  #
+    ######################################################
+    def subscopable?
+      false
+    end
+
+    def desc
+      nil
+    end
+
+    def backtrace
+      nil
+    end
+
+    def add_traces(*)
+      # noop
+    end
+
+    def traces
+      ScoutApm::TraceSet.new
+    end
+
+    #######################################################################
+    #  Many methods don't make any sense on a limited layer. Raise errors  #
+    #  aggressively for now to detect mistaken calls                      #
+    #######################################################################
+
+    def add_child
+      raise "Should never call add_child on a limited_layer"
+    end
+
+    def record_stop_time!(*)
+      raise "Should never call record_stop_time! on a limited_layer"
+    end
+
+    def record_allocations!
+      raise "Should never call record_allocations! on a limited_layer"
+    end
+
+    def desc=(*)
+      raise "Should never call desc on a limited_layer"
+    end
+
+    def annotate_layer(*)
+      raise "Should never call annotate_layer on a limited_layer"
+    end
+
+    def subscopable!
+      raise "Should never call subscopable! on a limited_layer"
+    end
+
+    def capture_backtrace!
+      raise "Should never call capture_backtrace on a limited_layer"
+    end
+
+    def caller_array
+      raise "Should never call caller_array on a limited_layer"
+    end
+  end
+end

data/lib/scout_apm/tracked_request.rb

@@ -57,20 +57,21 @@ module ScoutApm
     end
 
     def start_layer(layer)
-      if ignoring_children?
-        return
-      end
+      return if ignoring_children?
+
+      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
       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.
@@ -87,6 +88,8 @@ module ScoutApm
       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)
@@ -115,6 +118,8 @@ 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)
@@ -236,6 +241,8 @@ module ScoutApm
     end
 
     def instant?
+      return false if ignoring_request?
+
       instant_key
     end
 
@@ -248,6 +255,8 @@ module ScoutApm
     def record!
       @recorded = true
 
+      return if ignoring_request?
+
       # Bail out early if the user asked us to ignore this uri
       return if ScoutApm::Agent.instance.ignored_uris.ignore?(annotations[:uri])
 
@@ -297,6 +306,8 @@ module ScoutApm
 
     # 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
@@ -311,6 +322,8 @@ 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
 
@@ -359,5 +372,48 @@ module ScoutApm
     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
+    ################################################################################
+
+    # 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
   end
 end

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "3.0.0.pre3"
+  VERSION = "3.0.0.pre4"
 end

data/lib/scout_apm.rb

@@ -28,6 +28,8 @@ require 'scout_apm/version'
 
 require 'scout_apm/tracked_request'
 require 'scout_apm/layer'
+require 'scout_apm/limited_layer'
+require 'scout_apm/layer_children_set'
 require 'scout_apm/request_manager'
 require 'scout_apm/call_set'
 
@@ -70,7 +72,6 @@ require 'scout_apm/instruments/mongoid'
 require 'scout_apm/instruments/redis'
 require 'scout_apm/instruments/influxdb'
 require 'scout_apm/instruments/elasticsearch'
-require 'scout_apm/instruments/delayed_job'
 require 'scout_apm/instruments/active_record'
 require 'scout_apm/instruments/action_controller_rails_2'
 require 'scout_apm/instruments/action_controller_rails_3_rails4'

data/scout_apm.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "m"
   s.add_development_dependency "simplecov"
   s.add_development_dependency "rake-compiler"
+  s.add_development_dependency "addressable"
 end

data/test/unit/instruments/net_http_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+require 'scout_apm/instruments/net_http'
+
+require 'addressable'
+
+class NetHttpTest < Minitest::Test
+  def setup
+    ScoutApm::Instruments::NetHttp.new.install
+  end
+
+  def test_request_scout_description_for_uri
+    req = Net::HTTP::Get.new(URI('http://example.org/here'))
+    assert_equal '/here', Net::HTTP.new('').request_scout_description(req)
+  end
+
+  def test_request_scout_description_for_addressable
+    req = Net::HTTP::Get.new(Addressable::URI.parse('http://example.org/here'))
+    assert_equal '/here', Net::HTTP.new('').request_scout_description(req)
+  end
+end

data/test/unit/layer_children_set_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+require 'scout_apm/layer_children_set'
+
+class LayerChildrenSetTest < Minitest::Test
+  SET = ScoutApm::LayerChildrenSet
+
+  def test_limit_default
+    assert_equal SET::DEFAULT_UNIQUE_CUTOFF, SET.new.unique_cutoff
+  end
+
+  # Add 5, make sure they're all in the children list we get back.
+  def test_add_layer_before_limit
+    s = SET.new(5)
+
+    5.times do
+      s << make_layer("LayerType", "LayerName")
+    end
+
+    children = s.to_a
+    assert_equal 5, children.size
+
+    # Don't care about order
+    (0..4).each do |i|
+      assert children.include?(lookup_layer(i))
+    end
+  end
+
+  def test_add_layer_after_limit
+    s = SET.new(5)
+
+    10.times do
+      s << make_layer("LayerType", "LayerName")
+    end
+
+    children = s.to_a
+    # 6 = 5 real ones + 1 merged.
+    assert_equal 6, children.size
+
+    # Don't care about order
+    (0..4).each do |i|
+      assert children.include?(lookup_layer(i))
+    end
+
+    # Don't care about order
+    (5..9).each do |i|
+      assert ! children.include?(lookup_layer(i))
+    end
+
+    limited_layer = children.last
+    assert_equal ScoutApm::LimitedLayer, limited_layer.class
+    assert_equal 5, limited_layer.count
+  end
+
+  def test_add_layer_with_different_type_after_limit
+    s = SET.new(5)
+
+    # Add 20 items
+    10.times do
+      s << make_layer("LayerType", "LayerName")
+      s << make_layer("DifferentLayerType", "LayerName")
+    end
+
+    children = s.to_a
+
+    # Tyo types, so 2 distinct limitdlayer objects
+    limited_layers = children.select{ |l| ScoutApm::LimitedLayer === l }
+    assert_equal 2, limited_layers.length
+
+    # 5 unchanged children each for the two layer types, plus the 2 limitd when each overran their limit
+    assert_equal 12, children.length
+    limited_layers.each { |ml| assert_equal 5, ml.count }
+  end
+
+  #############
+  #  Helpers  #
+  #############
+
+  def make_layer(type, name)
+    @made_layers ||= []
+    l = ScoutApm::Layer.new(type, name)
+    @made_layers << l
+    l
+  end
+
+  def lookup_layer(i)
+    @made_layers[i]
+  end
+end

data/test/unit/limited_layer_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+require 'ostruct'
+
+class LimitedLayerTest < Minitest::Test
+
+  def test_counts_while_absorbing
+    ll = ScoutApm::LimitedLayer.new("ActiveRecord")
+    assert_equal 0, ll.count
+
+    ll.absorb faux_layer("ActiveRecord", "User#Find", 2, 1, 200, 100)
+    assert_equal 1, ll.count
+
+    ll.absorb faux_layer("ActiveRecord", "User#Find", 2, 1, 200, 100)
+    assert_equal 2, ll.count
+  end
+
+  def test_sums_values_while_absorbing
+    ll = ScoutApm::LimitedLayer.new("ActiveRecord")
+
+    ll.absorb faux_layer("ActiveRecord", "User#Find", 2, 1, 200, 100)
+    assert_equal 1, ll.total_exclusive_time
+    assert_equal 2, ll.total_call_time
+    assert_equal 100, ll.total_exclusive_allocations
+    assert_equal 200, ll.total_allocations
+
+
+    ll.absorb faux_layer("ActiveRecord", "User#Find", 4, 3, 400, 300)
+    assert_equal 4, ll.total_exclusive_time           # 3 + 1
+    assert_equal 6, ll.total_call_time                # 4 + 2
+    assert_equal 400, ll.total_exclusive_allocations  # 300 + 100
+    assert_equal 600, ll.total_allocations            # 400 + 200
+  end
+
+  def test_the_name
+    ll = ScoutApm::LimitedLayer.new("ActiveRecord")
+    assert_equal "ActiveRecord/Limited", ll.legacy_metric_name
+  end
+
+  #############
+  #  Helpers  #
+  #############
+
+  def faux_layer(type, name, tct, tet, a_tct, a_tet)
+    OpenStruct.new(
+      :type => type,
+      :name => name,
+      :total_call_time => tct,
+      :total_exclusive_time => tet,
+      :total_allocations => a_tct,
+      :total_exclusive_allocations => a_tet,
+    )
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 3.0.0.pre3
+  version: 3.0.0.pre4
 platform: ruby
 authors:
 - Derek Haynes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-22 00:00:00.000000000 Z
+date: 2016-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -95,6 +95,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Monitors Ruby apps and reports detailed metrics on performance to Scout.
 email:
 - support@scoutapp.com
@@ -151,7 +165,6 @@ files:
 - lib/scout_apm/instruments/action_controller_rails_2.rb
 - lib/scout_apm/instruments/action_controller_rails_3_rails4.rb
 - lib/scout_apm/instruments/active_record.rb
-- lib/scout_apm/instruments/delayed_job.rb
 - lib/scout_apm/instruments/elasticsearch.rb
 - lib/scout_apm/instruments/grape.rb
 - lib/scout_apm/instruments/http_client.rb
@@ -171,6 +184,7 @@ files:
 - lib/scout_apm/layaway.rb
 - lib/scout_apm/layaway_file.rb
 - lib/scout_apm/layer.rb
+- lib/scout_apm/layer_children_set.rb
 - lib/scout_apm/layer_converters/allocation_metric_converter.rb
 - lib/scout_apm/layer_converters/converter_base.rb
 - lib/scout_apm/layer_converters/depth_first_walker.rb
@@ -180,6 +194,7 @@ files:
 - lib/scout_apm/layer_converters/request_queue_time_converter.rb
 - lib/scout_apm/layer_converters/slow_job_converter.rb
 - lib/scout_apm/layer_converters/slow_request_converter.rb
+- lib/scout_apm/limited_layer.rb
 - lib/scout_apm/metric_meta.rb
 - lib/scout_apm/metric_set.rb
 - lib/scout_apm/metric_stats.rb
@@ -241,8 +256,11 @@ files:
 - test/unit/histogram_test.rb
 - test/unit/ignored_uris_test.rb
 - test/unit/instruments/active_record_instruments_test.rb
+- test/unit/instruments/net_http_test.rb
 - test/unit/instruments/percentile_sampler_test.rb
 - test/unit/layaway_test.rb
+- test/unit/layer_children_set_test.rb
+- test/unit/limited_layer_test.rb
 - test/unit/metric_set_test.rb
 - test/unit/scored_item_set_test.rb
 - test/unit/serializers/payload_serializer_test.rb
@@ -291,8 +309,11 @@ test_files:
 - test/unit/histogram_test.rb
 - test/unit/ignored_uris_test.rb
 - test/unit/instruments/active_record_instruments_test.rb
+- test/unit/instruments/net_http_test.rb
 - test/unit/instruments/percentile_sampler_test.rb
 - test/unit/layaway_test.rb
+- test/unit/layer_children_set_test.rb
+- test/unit/limited_layer_test.rb
 - test/unit/metric_set_test.rb
 - test/unit/scored_item_set_test.rb
 - test/unit/serializers/payload_serializer_test.rb

data/lib/scout_apm/instruments/delayed_job.rb

@@ -1,57 +0,0 @@
-module ScoutApm
-  module Instruments
-    class DelayedJob
-      attr_reader :logger
-
-      def initialize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
-        @installed = false
-      end
-
-      def installed?
-        @installed
-      end
-
-      def install
-        @installed = true
-        if defined?(::Delayed::Worker)
-          ::Delayed::Worker.class_eval do
-            include ScoutApm::Tracer
-            include ScoutApm::Instruments::DelayedJobInstruments
-            alias run_without_scout_instruments run
-            alias run run_with_scout_instruments
-          end
-        end
-      end
-    end
-
-    module DelayedJobInstruments
-      def run_with_scout_instruments(job)
-        scout_method_name = method_from_handler(job.handler)
-        queue = job.queue
-        latency = (Time.now.to_f - job.created_at.to_f) * 1000
-
-        ScoutApm::Agent.instance.store.track_one!("Queue", queue, 0, {:extra_metrics => {:latency => latency}})
-        req = ScoutApm::RequestManager.lookup
-        req.job!
-        req.start_layer( ScoutApm::Layer.new("Job", scout_method_name) )
-
-        begin
-          run_without_scout_instruments(job)
-        rescue
-          req.error!
-          raise
-        ensure
-          req.stop_layer
-        end
-      end
-
-      def method_from_handler(handler)
-        job_handler = YAML.load(handler)
-        klass = job_handler.object.name
-        method = job_handler.method_name
-        "#{klass}##{method}"
-      end
-    end
-  end
-end