scout_apm 2.5.1 → 5.3.2

data/test/unit/auto_instrument/rescue_from.rb

@@ -0,0 +1,13 @@
+
+class BrokenController < ApplicationController
+  rescue_from Exception do |e|
+    if e.is_a? Pundit::NotAuthorizedError
+      unauthorized_error
+    elsif e.is_a? ActionController::ParameterMissing
+      error(status: 422, message: e.message)
+    else
+      log_error(e)
+      error message: 'Internal error', exception: e
+    end
+  end
+end

data/test/unit/auto_instrument_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+require 'scout_apm/auto_instrument'
+
+class AutoInstrumentTest < Minitest::Test
+  ROOT = File.expand_path("../../", __dir__)
+  
+  def source_path(name)
+    File.expand_path("auto_instrument/#{name}.rb", __dir__)
+  end
+
+  def instrumented_path(name)
+    File.expand_path("auto_instrument/#{name}-instrumented.rb", __dir__)
+  end
+
+  def instrumented_source(name)
+    File.read(instrumented_path(name))
+  end
+
+  # Autoinstruments adds a backtrace to each created layer. This is the full path to the
+  # test controller.rb file, which will be different on different environments.
+  # This normalizes backtraces across environments.
+  def normalize_backtrace(string)
+    string.gsub(ROOT, "ROOT")
+  end
+
+  # Use this to automatically update the test fixtures.
+  def update_instrumented_source(name)
+    source = ::ScoutApm::AutoInstrument::Rails.rewrite(source_path(name))
+    source = normalize_backtrace(source)
+    File.write(instrumented_path(name),source)
+  end
+
+  def test_controller_rewrite
+    # update_instrumented_source("controller")
+
+    assert_equal instrumented_source("controller"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("controller")))
+  end
+
+  def test_rescue_from_rewrite
+    # update_instrumented_source("rescue_from")
+
+    assert_equal instrumented_source("rescue_from"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("rescue_from")))
+  end
+
+  def test_assignments_rewrite
+    # update_instrumented_source("assignments")
+
+    assert_equal instrumented_source("assignments"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("assignments")))
+  end
+
+  def test_hanging_method_rewrite
+    ::ScoutApm::AutoInstrument::Rails.rewrite(source_path("hanging_method"))
+  end
+
+  def test_anonymous_block_value
+    ::ScoutApm::AutoInstrument::Rails.rewrite(source_path("anonymous_block_value"))
+  end
+end if defined? ScoutApm::AutoInstrument

data/test/unit/background_job_integrations/sidekiq_test.rb

@@ -3,8 +3,25 @@ require 'scout_apm/request_manager'
 require 'scout_apm/background_job_integrations/sidekiq'
 
 class SidekiqTest < Minitest::Test
+  SidekiqIntegration = ScoutApm::BackgroundJobIntegrations::Sidekiq
   SidekiqMiddleware = ScoutApm::BackgroundJobIntegrations::SidekiqMiddleware
 
+  ########################################
+  # Install
+  ########################################
+  if (ENV["SCOUT_TEST_FEATURES"] || "").include?("sidekiq_install")
+    require 'sidekiq'
+
+    # Sidekiq::CLI needs to be defined in order for `Sidekiq.configure_server` to work
+    Sidekiq::CLI = nil
+
+    def test_starts_on_startup
+      ::ScoutApm::Agent.any_instance.expects(:start)
+      SidekiqIntegration.new.install
+      Sidekiq.options[:lifecycle_events][:startup].map(&:call)
+    end
+  end
+
   ########################################
   # Middleware
   ########################################

data/test/unit/environment_test.rb

@@ -44,8 +44,8 @@ class EnvironmentTest < Minitest::Test
   end
 
   def clean_fake_rails
-    Kernel.const_unset("Rails") if defined?(Kernel::Rails)
-    Kernel.const_unset("ActionController") if defined?(Kernel::ActionController)
+    Kernel.send(:remove_const, "Rails") if defined?(Kernel::Rails)
+    Kernel.send(:remove_const, "ActionController") if defined?(Kernel::ActionController)
   end
 
   def fake_sinatra

data/test/unit/error_service/error_buffer_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class ErrorBufferTest < Minitest::Test
+  class FakeError < StandardError
+  end
+
+  def test_captures_and_stores_exceptions_and_env
+    eb = ScoutApm::ErrorService::ErrorBuffer.new(context)
+    eb.capture(ex, env)
+  end
+
+  #### Helpers
+
+  def context
+    ScoutApm::AgentContext.new
+  end
+
+  def env
+    {}
+  end
+
+  def ex(msg="Whoops")
+    FakeError.new(msg)
+  end
+end

data/test/unit/error_service/ignored_exceptions_test.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+class IgnoredExceptionsTest < Minitest::Test
+  class FakeError < StandardError
+  end
+
+  class SubclassFakeError < FakeError
+  end
+
+  def test_ignores_with_string_match
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["RuntimeError"])
+    assert ig.ignored?(RuntimeError.new("something went wrong"))
+    assert !ig.ignored?(FakeError.new("something went wrong"))
+  end
+
+  def test_ignores_with_block
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, [])
+    ig.add_callback { |e| e.message == "ignore me" }
+
+    should_ignore = RuntimeError.new("ignore me")
+    should_not_ignore = RuntimeError.new("super legit")
+
+    assert ig.ignored?(should_ignore)
+    assert !ig.ignored?(should_not_ignore)
+  end
+
+  def test_ignores_subclasses
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["IgnoredExceptionsTest::FakeError"])
+    assert ig.ignored?(SubclassFakeError.new("Subclass"))
+  end
+
+  # Check that a bad exception in the list doesn't stop the whole thing from working
+  def test_does_not_consider_unknown_errors
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["ThisDoesNotExist", "IgnoredExceptionsTest::FakeError"])
+    assert ig.ignored?(FakeError.new("ignore this one"))
+  end
+
+  def test_add_module
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, [])
+    ig.add(IgnoredExceptionsTest::FakeError)
+    assert ig.ignored?(FakeError.new("ignore this one"))
+  end
+
+  #### Helpers
+
+  def context
+    ScoutApm::AgentContext.new
+  end
+end

data/test/unit/external_service_metric_set_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+require 'scout_apm/external_service_metric_set'
+
+module ScoutApm
+class ExternalServiceMetricSetTest < Minitest::Test
+  def test_hard_limit
+    config = make_fake_config(
+      'external_service_metric_limit' => 5, # The hard limit on db metrics
+      'external_service_metric_report_limit' => 2
+    )
+    context = ScoutApm::AgentContext.new().tap{|c| c.config = config }
+    set = ExternalServiceMetricSet.new(context)
+
+    set << fake_stat("a", 10)
+    set << fake_stat("b", 20)
+    set << fake_stat("c", 30)
+    set << fake_stat("d", 40)
+    set << fake_stat("e", 50)
+    set << fake_stat("f", 60)
+
+    assert_equal 5, set.metrics.size
+  end
+
+  def test_report_limit
+    config = make_fake_config(
+      'external_service_metric_limit' => 50, # much larger max, uninterested in hitting it.
+      'external_service_metric_report_limit' => 2
+    )
+    context = ScoutApm::AgentContext.new().tap{|c| c.config = config }
+    set = ExternalServiceMetricSet.new(context)
+    set << fake_stat("a", 10)
+    set << fake_stat("b", 20)
+    set << fake_stat("c", 30)
+    set << fake_stat("d", 40)
+    set << fake_stat("e", 50)
+    set << fake_stat("f", 60)
+
+    assert_equal 2, set.metrics_to_report.size
+    assert_equal ["f","e"], set.metrics_to_report.map{|m| m.key}
+  end
+
+  def test_combine
+    config = make_fake_config(
+      'external_service_metric_limit' => 5, # The hard limit on db metrics
+      'external_service_metric_report_limit' => 2
+    )
+    context = ScoutApm::AgentContext.new().tap{|c| c.config = config }
+    set1 = ExternalServiceMetricSet.new(context)
+    set1 << fake_stat("a", 10)
+    set1 << fake_stat("b", 20)
+    set2 = ExternalServiceMetricSet.new(context)
+    set2 << fake_stat("c", 10)
+    set2 << fake_stat("d", 20)
+
+    combined = set1.combine!(set2)
+    assert_equal ["a", "b", "c", "d"], combined.metrics.map{|_k, m| m.key}.sort
+  end
+
+  def fake_stat(key, call_time)
+    OpenStruct.new(
+      :key => key,
+      :call_time => call_time
+    )
+  end
+end
+end

data/test/unit/external_service_metric_stats_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+require 'scout_apm/external_service_metric_stats'
+
+module ScoutApm
+class ExternalServiceMetricStatsTest < Minitest::Test
+  def test_as_json_empty_stats
+    stat = build("example.com", "GET", "Controller/public/index", 1, 10)
+
+    assert_equal({
+      :domain_name => "example.com",
+      :operation => "GET",
+      :call_count => 1,
+      :transaction_count => 0,
+      :scope => "Controller/public/index",
+      :histogram => [[10.0, 1]],
+
+      :max_call_time => 10.0,
+      :min_call_time => 10.0,
+      :call_time => 10.0
+    }, stat.as_json)
+  end
+
+  def test_increment_transaction_count
+    stat = build()
+    assert_equal 0, stat.transaction_count
+
+    stat.increment_transaction_count!
+
+    assert_equal 1, stat.transaction_count
+  end
+
+  def test_key_name
+    stat = build("example.com", "GET", "Controller/public/index")
+    assert_equal ["example.com", "GET", "Controller/public/index"], stat.key
+  end
+
+  def test_combine_min_call_time_picks_smallest
+    stat1, stat2 = build_pair
+    assert_equal 5.1,  stat1.combine!(stat2).min_call_time
+  end
+
+  def test_combine_max_call_time_picks_largest
+    stat1, stat2 = build_pair
+    assert_equal 8.2,  stat1.combine!(stat2).max_call_time
+  end
+
+  def test_combine_call_counts_adds
+    stat1, stat2 = build_pair
+    assert_equal 5, stat1.combine!(stat2).call_count
+  end
+
+  def test_combine_transaction_count_adds
+    stat1, stat2 = build_pair
+    2.times { stat1.increment_transaction_count! }
+    3.times { stat2.increment_transaction_count! }
+
+    assert_equal 5, stat1.combine!(stat2).call_count
+  end
+
+  def test_combine_doesnt_merge_with_self
+    stat = build
+    merged = stat.combine!(stat)
+
+    assert_equal DEFAULTS[:call_count], merged.call_count
+    assert_equal DEFAULTS[:call_time], merged.call_time
+  end
+
+  # A.combine!(B) should be the the same as B.combine!(A)
+  # Have to be a bit careful, since combine! is destructive, so make two pairs
+  # with same data to do both sides, then check that they result in the same
+  # answer
+  [:transaction_count, :call_count, :max_call_time, :min_call_time].each do |attr|
+    define_method :"test_combine_#{attr}_is_symmetric" do
+      stat1_a, stat2_a = build_pair
+      stat1_b, stat2_b = build_pair
+      merged_a = stat1_a.combine!(stat2_a)
+      merged_b = stat2_b.combine!(stat1_b)
+
+      assert_equal merged_a.send(attr), merged_b.send(attr)
+    end
+  end
+
+  #############
+  #  Helpers  #
+  #############
+  DEFAULTS = {
+    :call_count => 1,
+    :call_time => 10.0,
+  }
+
+  def build(domain_name="example.com",
+            operation="GET",
+            scope="Controller/public/index",
+            call_count=DEFAULTS[:call_count],
+            call_time=DEFAULTS[:call_time])
+    ExternalServiceMetricStats.new(domain_name, operation, scope, call_count, call_time)
+  end
+
+  def build_pair
+    stat1 = build("example.com", "GET", "Controller/public/index", 2, 5.1)
+    stat2 = build("example.com", "GET", "Controller/public/index", 3, 8.2)
+    [stat1, stat2]
+  end
+end
+end

data/test/unit/ignored_uris_test.rb

@@ -13,4 +13,10 @@ class IgnoredUrlsTest < Minitest::Test
     i = ScoutApm::IgnoredUris.new(["/slow", "/health"])
     assert_equal false, i.ignore?("/users/2/health")
   end
+
+  def test_does_not_ignore_empty_string
+    i = ScoutApm::IgnoredUris.new(["", "/admin"])
+    assert_equal false, i.ignore?("/users/2/health")
+    assert_equal true, i.ignore?("/admin/dashboard")
+  end
 end

data/test/unit/instruments/active_record_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'sqlite3'
+require 'active_record'
+
+begin
+  require 'octoshark'
+rescue LoadError
+  # Ignore
+end
+
+class ActiveRecordTest < Minitest::Test
+  def database_path
+    File.expand_path('test.sqlite3', DATA_FILE_DIR)
+  end
+
+  def setup
+    database = SQLite3::Database.new(database_path)
+    database.execute("DROP TABLE IF EXISTS users;")
+    database.execute("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(100));")
+
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => database_path)
+  end
+
+  class User < ActiveRecord::Base
+  end
+
+  def test_instrumentation
+    recorder = FakeRecorder.new
+    agent_context.recorder = recorder
+
+    instrument = ScoutApm::Instruments::ActiveRecord.new(agent_context)
+    instrument.install(prepend: false)
+
+    ScoutApm::Tracer.instrument("Controller", "foo/bar") do
+      user = User.create
+    end
+
+    assert 1, recorder.requests.size
+  end
+end

data/test/unit/instruments/http_client_test.rb

@@ -0,0 +1,24 @@
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
+  require 'test_helper'
+
+  require 'scout_apm/instruments/http_client'
+
+  require 'httpclient'
+
+  class HttpClientTest < Minitest::Test
+    def setup
+      @context = ScoutApm::AgentContext.new
+      @instance = ScoutApm::Instruments::HttpClient.new(@context)
+      @instrument_manager = ScoutApm::InstrumentManager.new(@context)
+      @instance.install(prepend: @instrument_manager.prepend_for_instrument?(@instance.class))
+    end
+
+    def test_installs_using_proper_method
+      if @instrument_manager.prepend_for_instrument?(@instance.class) == true
+        assert ::HTTPClient.ancestors.include?(ScoutApm::Instruments::HttpClientInstrumentationPrepend)
+      else
+        assert_equal false, ::HTTPClient.ancestors.include?(ScoutApm::Instruments::HttpClientInstrumentationPrepend)
+      end
+    end
+  end
+end

data/test/unit/instruments/http_test.rb

@@ -0,0 +1,24 @@
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
+  require 'test_helper'
+
+  require 'scout_apm/instruments/http'
+
+  require 'http'
+
+  class HttpTest < Minitest::Test
+    def setup
+      @context = ScoutApm::AgentContext.new
+      @instance = ScoutApm::Instruments::HTTP.new(@context)
+      @instrument_manager = ScoutApm::InstrumentManager.new(@context)
+      @instance.install(prepend: @instrument_manager.prepend_for_instrument?(@instance.class))
+    end
+
+    def test_installs_using_proper_method
+      if @instrument_manager.prepend_for_instrument?(@instance.class) == true
+        assert ::HTTP::Client.ancestors.include?(ScoutApm::Instruments::HTTPInstrumentationPrepend)
+      else
+        assert_equal false, ::HTTP::Client.ancestors.include?(ScoutApm::Instruments::HTTPInstrumentationPrepend)
+      end
+    end
+  end
+end

data/test/unit/instruments/moped_test.rb

@@ -0,0 +1,24 @@
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
+  require 'test_helper'
+
+  require 'scout_apm/instruments/moped'
+
+  require 'moped'
+
+  class MopedTest < Minitest::Test
+    def setup
+      @context = ScoutApm::AgentContext.new
+      @instance = ScoutApm::Instruments::Moped.new(@context)
+      @instrument_manager = ScoutApm::InstrumentManager.new(@context)
+      @instance.install(prepend: @instrument_manager.prepend_for_instrument?(@instance.class))
+    end
+
+    def test_installs_using_proper_method
+      if @instrument_manager.prepend_for_instrument?(@instance.class) == true
+        assert ::Moped::Node.ancestors.include?(ScoutApm::Instruments::MopedInstrumentationPrepend)
+      else
+        assert_equal false, ::Moped::Node.ancestors.include?(ScoutApm::Instruments::MopedInstrumentationPrepend)
+      end
+    end
+  end
+end

data/test/unit/instruments/net_http_test.rb

@@ -7,7 +7,9 @@ require 'addressable/uri'
 class NetHttpTest < Minitest::Test
   def setup
     @context = ScoutApm::AgentContext.new
-    ScoutApm::Instruments::NetHttp.new(@context).install
+    @instance = ScoutApm::Instruments::NetHttp.new(@context)
+    @instrument_manager = ScoutApm::InstrumentManager.new(@context)
+    @instance.install(prepend: @instrument_manager.prepend_for_instrument?(@instance.class))
   end
 
   def test_request_scout_description_for_uri
@@ -24,4 +26,12 @@ class NetHttpTest < Minitest::Test
     req = Net::HTTP::Get.new(Addressable::URI.parse('http://example.org/here'))
     assert_equal '/here', Net::HTTP.new('').request_scout_description(req)
   end
+
+  def test_installs_using_proper_method
+    if @instrument_manager.prepend_for_instrument?(@instance.class) == true
+      assert Net::HTTP.ancestors.include?(ScoutApm::Instruments::NetHttpInstrumentationPrepend)
+    else
+      assert_equal false, Net::HTTP.ancestors.include?(ScoutApm::Instruments::NetHttpInstrumentationPrepend)
+    end
+  end
 end

data/test/unit/instruments/redis_test.rb

@@ -0,0 +1,24 @@
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
+  require 'test_helper'
+
+  require 'scout_apm/instruments/redis5'
+
+  require 'redis'
+
+  class RedisTest < Minitest::Test
+    def setup
+      @context = ScoutApm::AgentContext.new
+      @instance = ScoutApm::Instruments::Redis5.new(@context)
+      @instrument_manager = ScoutApm::InstrumentManager.new(@context)
+      @instance.install(prepend: @instrument_manager.prepend_for_instrument?(@instance.class))
+    end
+
+    def test_installs_using_proper_method
+      if @instrument_manager.prepend_for_instrument?(@instance.class) == true
+        assert ::Redis::Client.ancestors.include?(ScoutApm::Instruments::Redis5ClientInstrumentationPrepend)
+      else
+        assert_equal false, ::Redis::Client.ancestors.include?(ScoutApm::Instruments::Redis5ClientInstrumentationPrepend)
+      end
+    end
+  end
+end

data/test/unit/instruments/typhoeus_test.rb

@@ -0,0 +1,42 @@
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("typhoeus")
+  require 'test_helper'
+
+  require 'scout_apm/instruments/typhoeus'
+
+  require 'typhoeus'
+
+  class TyphoeusTest < Minitest::Test
+    def setup
+      @context = ScoutApm::AgentContext.new
+      @recorder = FakeRecorder.new
+      ScoutApm::Agent.instance.context.recorder = @recorder
+      ScoutApm::Instruments::Typhoeus.new(@context).install(prepend: false)
+    end
+
+    def test_instruments_typhoeus_hydra
+      hydra = Typhoeus::Hydra.new
+      2.times.map{ hydra.queue(Typhoeus::Request.new("example.com", followlocation: true)) }
+
+      assert_equal "2 requests", hydra.scout_desc
+
+      hydra.run
+      assert_equal "0 requests", hydra.scout_desc
+      assert_recorded(@recorder, "HTTP", "Hydra", "2 requests")
+    end
+
+    def test_instruments_typhoeus
+      Typhoeus.get("example.com", followlocation: true)
+      assert_recorded(@recorder, "HTTP", "get", "example.com")
+    end
+
+    private
+
+    def assert_recorded(recorder, type, name, desc = nil)
+      req = recorder.requests.first
+      assert req, "recorder recorded no layers"
+      assert_equal type, req.root_layer.type
+      assert_equal name, req.root_layer.name
+      assert_equal desc, req.root_layer.desc if !desc.nil?
+    end
+  end
+end

data/test/unit/layer_children_set_test.rb

@@ -71,6 +71,15 @@ class LayerChildrenSetTest < Minitest::Test
     limited_layers.each { |ml| assert_equal 5, ml.count }
   end
 
+  def test_works_with_marshal
+    s = SET.new(5)
+    10.times do
+      s << make_layer("LayerType", "LayerName")
+    end
+
+    Marshal.dump(s)
+  end
+
   #############
   #  Helpers  #
   #############

data/test/unit/remote/{test_server.rb → server_test.rb}

@@ -8,8 +8,11 @@ class TestRemoteServer < Minitest::Test
     logger_io = StringIO.new
     server = ScoutApm::Remote::Server.new(bind, port, router, Logger.new(logger_io))
 
+    # Cannot test this if we can't require webrick. Ruby 3 stopped including by default
+    skip unless server.require_webrick
+
     server.start
-    sleep 0.01 # Let the server finish starting. The assert should instead allow a time
+    sleep 0.05 # Let the server finish starting. The assert should instead allow a time
     assert server.running?
   end
 end

data/test/unit/request_histograms_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+require 'scout_apm/request_histograms'
+
+class RequestHistogramsTest < Minitest::Test
+  def test_as_json_without_activesupport
+    rh = ScoutApm::RequestHistograms.new
+
+    rh.add("foo", 1)
+    rh.add("foo", 2)
+    rh.add("bar", 3)
+
+    j = rh.as_json
+    assert_equal 2, j.size
+    assert_equal ["bar", "foo"], j.keys.sort
+  end
+end