scout_apm 2.2.0.pre3 → 2.3.0.pre

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/instruments/percentile_sampler_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+require 'scout_apm/instruments/percentile_sampler'
+
+class PercentileSamplerTest < Minitest::Test
+  PercentileSampler = ScoutApm::Instruments::PercentileSampler
+  HistogramReport = ScoutApm::Instruments::HistogramReport
+
+  attr_reader :subject
+
+  def setup
+    @subject = PercentileSampler.new(logger, histograms)
+  end
+
+
+  def test_initialize_with_logger_and_histogram_set
+    assert_equal subject.logger, logger
+    assert_equal subject.histograms, histograms
+  end
+
+  def test_implements_instrument_interface
+    assert subject.respond_to?(:human_name)
+  end
+
+  def test_percentiles_returns_one_percentile_per_endpoint_at_time
+    histograms[time].add("foo", 10)
+    histograms[time].add("bar", 15)
+    histograms[time2].add("baz", 15)
+
+    assert_equal subject.percentiles(time).length, 2
+    assert_equal subject.percentiles(time2).length, 1
+  end
+
+  def test_percentiles_clears_time_from_hash
+    histograms[time].add("foo", 10)
+    histograms[time2].add("baz", 15)
+
+    subject.percentiles(time)
+
+    assert_false histograms.key?(time)
+    assert       histograms.key?(time + 10)
+  end
+
+  def test_percentiles_returns_histogram_reports
+    histograms[time].add("foo", 10)
+
+    assert subject.percentiles(time).
+      all?{ |item| item.is_a?(HistogramReport) }
+  end
+
+  def test_percentiles_returns_correct_histogram_report
+    histograms[time].add("foo", 100)
+    histograms[time].add("foo", 200)
+    histograms[time].add("foo", 100)
+    histograms[time].add("foo", 300)
+
+    report = subject.percentiles(time).first
+    histogram = report.histogram
+
+    assert_equal "foo", report.name
+    assert_equal 4, histogram.total
+    assert_equal [[2, 100], [1, 200], [1, 300]],
+      histogram.bins.map{|bin| [bin.count, bin.value] }
+  end
+
+  def test_metrics_saves_histogram_to_store
+    store = mock
+    store.expects(:track_histograms!)
+    subject.metrics(ScoutApm::StoreReportingPeriodTimestamp.new(time), store)
+  end
+
+
+  ################################################################################
+  # HistogramReport Test
+  ################################################################################
+  def test_histogram_report_combine_refuses_to_combine_mismatched_name
+    assert_raises { HistogramReport.new("foo", histogram).combine!(HistogramReport.new("bar", histogram)) }
+  end
+
+  def test_histogram_report_merge_keeps_name
+    report1 = HistogramReport.new("foo", histogram)
+    report2 = HistogramReport.new("foo", histogram)
+    combined = report1.combine!(report2)
+
+    assert "foo", combined.name
+  end
+
+  def test_histogram_report_combine_merges_histograms
+    histogram1 = histogram
+    histogram2 = histogram
+    histogram1.add(1)
+    histogram1.add(2)
+    histogram2.add(2)
+    histogram2.add(3)
+
+    report1 = HistogramReport.new("foo", histogram1)
+    report2 = HistogramReport.new("foo", histogram2)
+    combined = report1.combine!(report2)
+
+    assert_equal 4, combined.histogram.total
+    assert_equal [[1, 1], [2, 2], [1, 3]],
+      combined.histogram.bins.map{|bin| [bin.count, bin.value.to_i] }
+  end
+
+  ################################################################################
+  # Test Helpers
+  ################################################################################
+  def logger
+    @logger ||= begin
+                  @logger_io = StringIO.new
+                  Logger.new(@logger_io)
+                end
+  end
+
+  def histograms
+    @histograms ||= begin
+                      @request_histograms_by_time = Hash.new { |hash, key|
+                        hash[key] = ScoutApm::RequestHistograms.new
+                      }
+                    end
+  end
+
+  def histogram
+    max_bins = 20
+    ScoutApm::NumericHistogram.new(max_bins)
+  end
+
+  # An arbitrary time
+  def time
+    @time ||= Time.now
+  end
+
+  def time2
+    time + 10
+  end
+end
+

data/test/unit/layaway_test.rb

@@ -21,4 +21,24 @@ class LayawayTest < Minitest::Test
 
     assert_equal Pathname.new("/tmp/scout_apm_test/tmp"), ScoutApm::Layaway.new(config, env).directory
   end
+
+  def test_layaway_file_limit_prevents_new_writes
+    FileUtils.mkdir_p '/tmp/scout_apm_test/layaway_limit'
+    config = make_fake_config("data_file" => "/tmp/scout_apm_test/layaway_limit")
+    layaway = ScoutApm::Layaway.new(config, ScoutApm::Agent.instance.environment)
+    layaway.delete_files_for(:all)
+
+    current_time = Time.now.utc
+    current_rp = ScoutApm::StoreReportingPeriod.new(current_time)
+    stale_rp = ScoutApm::StoreReportingPeriod.new(current_time - current_time.sec - 120)
+
+    # layaway.write_reporting_period returns nil on successful write
+    # It should probably be changed to return true or the number of bytes written
+    assert_nil layaway.write_reporting_period(stale_rp, 1)
+
+    # layaway.write_reporting_period returns an explicit false class on failure
+    assert layaway.write_reporting_period(current_rp, 1).is_a?(FalseClass)
+
+    layaway.delete_files_for(:all)
+  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/layer_converters/depth_first_walker_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module ScoutApm
+class DepthFirstWalkerTest < Minitest::Test
+  def test_walk_single_node_calls_callbacks_in_order
+    calls = []
+    layer = Layer.new("A", "x")
+
+    walker = LayerConverters::DepthFirstWalker.new(layer)
+    walker.before { |l| calls << :before }
+    walker.after { |l| calls << :after }
+    walker.on { |l| calls << :on }
+
+    walker.walk
+
+    assert_equal [:before, :on, :after], calls
+  end
+
+  # Tree looks like:
+  #    A
+  #    |
+  #    B
+  #  / \ \
+  #  C  D E
+  # / \
+  # F  G
+  def test_walk_interesting_tree
+    calls = []
+    a = Layer.new("A", "x")
+    b = Layer.new("B", "x")
+    c = Layer.new("C", "x")
+    d = Layer.new("D", "x")
+    e = Layer.new("E", "x")
+    f = Layer.new("F", "x")
+    g = Layer.new("G", "x")
+    a.add_child(b)
+    b.add_child(c)
+    b.add_child(d)
+    b.add_child(e)
+    c.add_child(f)
+    c.add_child(g)
+
+    root_layer = a
+
+    walker = LayerConverters::DepthFirstWalker.new(root_layer)
+    walker.before { |l| calls << "#{l.type} before" }
+    walker.after { |l| calls << "#{l.type} after" }
+    walker.on { |l| calls << "#{l.type} on" }
+
+    walker.walk
+
+    assert_equal [
+      "A before", "A on", # before & on always line up next to each other
+      "B before", "B on",
+      "C before", "C on",
+      "F before", "F on", "F after", # leaf nodes run all 3
+      "G before", "G on", "G after",
+      "C after", # once all children are done, do a node's after
+      "D before", "D on", "D after",
+      "E before", "E on", "E after",
+      "B after",
+      "A after"
+    ], calls
+  end
+end
+end

data/test/unit/layer_converters/metric_converter_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+require_relative 'stubs'
+
+module ScoutApm
+module LayerConverters
+class MetricConverterTest < Minitest::Test
+  include Stubs
+
+  def test_register_adds_hooks
+    mc = MetricConverter.new(faux_request, faux_layer_finder, faux_store)
+    faux_walker.expects(:on)
+    mc.register_hooks(faux_walker)
+  end
+
+  def test_record
+    mc = MetricConverter.new(faux_request, faux_layer_finder, faux_store)
+    faux_store.expects(:track!)
+    mc.record!
+  end
+end
+end
+end

data/test/unit/layer_converters/stubs.rb

@@ -0,0 +1,33 @@
+####################################
+#  Stubs for LayerConverter Tests  #
+####################################
+module ScoutApm
+  module LayerConverters
+    module Stubs
+      def faux_walker(subscope_stubs: true)
+        @w ||= stub
+
+        if subscope_stubs && !@w_set_subscope_stubs
+          @w_set_subscope_stubs = true
+          @w.expects(:before)
+          @w.expects(:after)
+        end
+        @w
+      end
+
+      def faux_request
+        @req ||= stub(:root_layer => stub)
+      end
+
+      def faux_layer_finder
+        @layer_finder ||= stub
+        @layer_finder.stubs(scope: stub)
+        @layer_finder
+      end
+
+      def faux_store
+        @store ||= stub
+      end
+    end
+  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