scout_apm 2.1.32 → 2.2.0.pre0

data/test/unit/background_job_integrations/sidekiq_test.rb

@@ -1,104 +0,0 @@
-require 'test_helper'
-require 'scout_apm/request_manager'
-require 'scout_apm/background_job_integrations/sidekiq'
-
-class SidekiqTest < Minitest::Test
-  SidekiqMiddleware = ScoutApm::BackgroundJobIntegrations::SidekiqMiddleware
-
-  ########################################
-  # Middleware
-  ########################################
-  def test_middleware_call_happy_path
-    fake_request = mock
-    fake_request.expects(:annotate_request)
-    fake_request.expects(:job!)
-    fake_request.expects(:start_layer).twice
-    fake_request.expects(:stop_layer).twice
-    fake_request.expects(:error!).never
-
-    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
-
-    block_called = false
-    msg = { 'class' => 'MyJobClass',
-            'created_at' => Time.now }
-
-    SidekiqMiddleware.new.call(nil, msg, "defaultqueue") { block_called = true }
-    assert_equal true, block_called
-  end
-
-  def test_middleware_call_job_exception
-    fake_request = mock
-    fake_request.expects(:annotate_request)
-    fake_request.expects(:job!)
-    fake_request.expects(:start_layer).twice
-    fake_request.expects(:stop_layer).twice
-    fake_request.expects(:error!)
-
-    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
-
-    msg = { 'class' => 'MyJobClass',
-            'created_at' => Time.now }
-
-    assert_raises RuntimeError do
-      SidekiqMiddleware.new.call(nil, msg, "defaultqueue") { raise "TheJobFailed" }
-    end
-  end
-
-  def test_middleware_call_edge_cases
-    fake_request = mock
-    fake_request.expects(:annotate_request)
-    fake_request.expects(:job!)
-    fake_request.expects(:start_layer).twice
-    fake_request.expects(:stop_layer).twice
-    fake_request.expects(:error!)
-
-    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
-
-    # msg doesn't have anything
-    msg = { }
-
-    assert_raises RuntimeError do
-      SidekiqMiddleware.new.call(nil, msg, "defaultqueue") { raise "TheJobFailed" }
-    end
-  end
-
-  ########################################
-  # Job Class Determination
-  ########################################
-  def test_job_class_name_normally
-    msg = { 'class' => 'AGreatJob' }
-    assert_equal 'AGreatJob', SidekiqMiddleware.new.job_class(msg)
-  end
-
-  def test_job_class_name_activejob
-    msg = { 'class' => 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper',
-            'wrapped' => 'RealJobClass' }
-    assert_equal 'RealJobClass', SidekiqMiddleware.new.job_class(msg)
-  end
-
-  def test_job_class_name_error_default
-    msg = {}
-    assert_equal 'UnknownJob', SidekiqMiddleware.new.job_class(msg)
-  end
-
-  ########################################
-  # Latency Calculation
-  ########################################
-  def test_latency_from_created_at
-    # Created at time 80, but now it is 200. Latency was 120
-    msg = { 'created_at' => 80 }
-    assert_equal 120, SidekiqMiddleware.new.latency(msg, 200)
-  end
-
-  def test_latency_from_enqueued_at
-    # Created at time 80, but now it is 200. Latency was 120
-    msg = { 'enqueued_at' => 80 }
-    assert_equal 120, SidekiqMiddleware.new.latency(msg, 200)
-  end
-
-  def test_latency_fallback
-    # No created at time, so fall back to 0
-    msg = {}
-    assert_equal 0, SidekiqMiddleware.new.latency(msg, 200)
-  end
-end

data/test/unit/context_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-require 'scout_apm/context'
-
-class ContextText < Minitest::Test
-  def test_ignore_nil_value
-    context = ScoutApm::Context.new
-    assert hash = context.add(:nil_key => nil, :org => 'org')
-    assert_equal ({:org => 'org'}), hash
-  end
-
-  def test_ignore_nil_key
-    context = ScoutApm::Context.new
-    assert hash = context.add(nil => nil, :org => 'org')
-    assert_equal ({:org => 'org'}), hash
-  end
-
-  def test_ignore_unsupported_value_type
-    context = ScoutApm::Context.new
-    assert hash = context.add(:array => [1,2,3,4], :org => 'org')
-    assert_equal ({:org => 'org'}), hash
-  end
-
-  def test_ignore_unsupported_key_type
-    context = ScoutApm::Context.new
-    assert hash = context.add([1,2,3,4] => 'hey', :org => 'org')
-    assert_equal ({:org => 'org'}), hash
-  end
-end
-

data/test/unit/git_revision_test.rb

@@ -1,15 +0,0 @@
-require 'test_helper'
-
-require 'scout_apm/git_revision'
-
-class GitRevisionTest < Minitest::Test
-  # TODO - other tests that would be nice:
-  # * ensure we only detect once, on initialize.
-  # * tests for reading cap files
-  
-  def test_sha_from_heroku
-    ENV['HEROKU_SLUG_COMMIT'] = 'heroku_slug'
-    revision = ScoutApm::GitRevision.new
-    assert_equal 'heroku_slug', revision.sha
-  end
-end

data/test/unit/instruments/net_http_test.rb

@@ -1,21 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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/layer_children_set_test.rb

@@ -1,88 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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