scout_apm 5.3.3 → 5.6.4

data/test/unit/auto_instrument_test.rb

@@ -4,7 +4,7 @@ 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
@@ -38,6 +38,12 @@ class AutoInstrumentTest < Minitest::Test
       normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("controller")))
   end
 
+  def test_controller_rewrite_hash_shorthand
+    skip if RUBY_VERSION < "3.1"
+    assert_equal instrumented_source("hash_shorthand_controller"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("hash_shorthand_controller")))
+  end
+
   def test_rescue_from_rewrite
     # update_instrumented_source("rescue_from")
 

data/test/unit/background_job_integrations/sidekiq_test.rb

@@ -18,7 +18,9 @@ class SidekiqTest < Minitest::Test
     def test_starts_on_startup
       ::ScoutApm::Agent.any_instance.expects(:start)
       SidekiqIntegration.new.install
-      Sidekiq.options[:lifecycle_events][:startup].map(&:call)
+      ::Sidekiq.configure_server do |config|
+        config[:lifecycle_events][:startup].map(&:call)
+      end
     end
   end
 
@@ -100,13 +102,21 @@ class SidekiqTest < Minitest::Test
   ########################################
   def test_latency_from_created_at
     # Created at time 80, but now it is 200. Latency was 120
-    msg = { 'created_at' => 80 }
+    msg = if SidekiqMiddleware.sidekiq_version_8?
+            { 'created_at' => 80000 } # milliseconds for Sidekiq 8+
+          else
+            { 'created_at' => 80 }
+          end
     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 }
+    msg = if SidekiqMiddleware.sidekiq_version_8?
+            { 'enqueued_at' => 80000 } # milliseconds for Sidekiq 8+
+          else
+            { 'enqueued_at' => 80 }
+          end
     assert_equal 120, SidekiqMiddleware.new.latency(msg, 200)
   end
 

data/test/unit/config_test.rb

@@ -72,6 +72,26 @@ class ConfigTest < Minitest::Test
     assert_equal ["a"], coercion.coerce(["a"])
   end
 
+  def test_integer_coercion
+    coercion = ScoutApm::Config::IntegerCoercion.new
+    assert_equal 1, coercion.coerce("1")
+    assert_equal 1, coercion.coerce(1)
+    assert_equal 0, coercion.coerce("0")
+    assert_equal 0, coercion.coerce(0)
+    assert_equal 0, coercion.coerce("")
+    assert_equal 0, coercion.coerce(nil)
+  end
+
+  def test_nullable_integer_coercion
+    coercion = ScoutApm::Config::NullableIntegerCoercion.new
+    assert_equal 1, coercion.coerce("1")
+    assert_equal 1, coercion.coerce(1)
+    assert_equal 0, coercion.coerce("0")
+    assert_equal 0, coercion.coerce(0)
+    assert_equal 0, coercion.coerce("")
+    assert_nil coercion.coerce(nil)
+  end
+
   def test_any_keys_found
     ENV.stubs(:has_key?).returns(nil)
 

data/test/unit/environment_test.rb

@@ -29,32 +29,4 @@ class EnvironmentTest < Minitest::Test
   def test_framework_ruby
     assert_equal :ruby, ScoutApm::Environment.send(:new).framework
   end
-
-  ############################################################
-
-  def fake_rails(version)
-    Kernel.const_set("Rails", Module.new)
-    Kernel.const_set("ActionController", Module.new)
-    r = Kernel.const_get("Rails")
-    r.const_set("VERSION", Module.new)
-    v = r.const_get("VERSION")
-    v.const_set("MAJOR", version)
-
-    assert_equal version, Rails::VERSION::MAJOR
-  end
-
-  def clean_fake_rails
-    Kernel.send(:remove_const, "Rails") if defined?(Kernel::Rails)
-    Kernel.send(:remove_const, "ActionController") if defined?(Kernel::ActionController)
-  end
-
-  def fake_sinatra
-    Kernel.const_set("Sinatra", Module.new)
-    s = Kernel.const_get("Sinatra")
-    s.const_set("Base", Module.new)
-  end
-
-  def clean_fake_sinatra
-    Kernel.const_unset("Sinatra") if defined?(Kernel::Sinatra)
-  end
 end

data/test/unit/git_revision_test.rb

@@ -3,13 +3,75 @@ 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 setup
+    @env = ENV.to_h
+  end
+
+  def teardown
+    ENV.replace(@env)
+  end
+
+  def test_sha_detected_once
+    ENV['HEROKU_SLUG_COMMIT'] = 'initial_slug'
+    revision = ScoutApm::GitRevision.new(ScoutApm::AgentContext.new)
+    assert_equal 'initial_slug', revision.sha
+
+    ENV['HEROKU_SLUG_COMMIT'] = 'new_slug'
+    assert_equal 'initial_slug', revision.sha
+  end
+
+  def test_sha_from_config
+    config = make_fake_config('revision_sha' => 'config_sha')
+    context = ScoutApm::AgentContext.new().tap { |c| c.config = config }
+    revision = ScoutApm::GitRevision.new(context)
+
+    assert_equal 'config_sha', revision.sha
+  end
 
   def test_sha_from_heroku
     ENV['HEROKU_SLUG_COMMIT'] = 'heroku_slug'
     revision = ScoutApm::GitRevision.new(ScoutApm::AgentContext.new)
     assert_equal 'heroku_slug', revision.sha
   end
+
+  def test_sha_from_capistrano
+    Dir.mktmpdir do |dir|
+      context = context_with_file_in_root(File.join(dir, 'REVISION'), 'capistrano_sha')
+      revision = ScoutApm::GitRevision.new(context)
+      assert_equal 'capistrano_sha', revision.sha
+    end
+  end
+
+  def test_sha_from_kamal
+    ENV['KAMAL_VERSION'] = 'kamal_sha'
+    revision = ScoutApm::GitRevision.new(ScoutApm::AgentContext.new)
+    assert_equal 'kamal_sha', revision.sha
+  end
+
+
+  def test_sha_from_mina
+    Dir.mktmpdir do |dir|
+      context = context_with_file_in_root(File.join(dir, '.mina_git_revision'), 'mina_sha')
+      revision = ScoutApm::GitRevision.new(context)
+      assert_equal 'mina_sha', revision.sha
+    end
+  end
+
+  def test_sha_from_git
+    short_sha = `git rev-parse --short HEAD`.strip
+    skip 'git not installed or not in a git repository' if short_sha.empty?
+
+    revision = ScoutApm::GitRevision.new(ScoutApm::AgentContext.new)
+    assert_equal short_sha, revision.sha
+  end
+
+  private
+
+  def context_with_file_in_root(file_name, contents)
+    config = make_fake_config({})
+    env = make_fake_environment(root: File.dirname(file_name))
+    File.write(file_name, contents)
+
+    ScoutApm::AgentContext.new().tap { |c| c.config = config; c.environment = env }
+  end
 end

data/test/unit/instruments/action_view_test.rb

@@ -0,0 +1,102 @@
+# Most of this was taken from Rails:
+# https://github.com/rails/rails/blob/v7.1.3/actionview/test/actionpack/controller/render_test.rb
+# https://github.com/rails/rails/blob/v7.1.3/actionview/test/abstract_unit.rb
+
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
+  require 'test_helper'
+  require 'action_view'
+  require 'action_pack'
+  require 'action_controller'
+
+  FIXTURE_LOAD_PATH = File.expand_path("fixtures", __dir__)
+
+  include ActionView::Context
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::TextHelper
+
+  module ActionController
+
+    class Base
+      self.view_paths = FIXTURE_LOAD_PATH
+
+      def self.test_routes(&block)
+        routes = ActionDispatch::Routing::RouteSet.new
+        routes.draw(&block)
+        include routes.url_helpers
+        routes
+      end
+    end
+
+    class TestCase
+      include ActionDispatch::TestProcess
+
+      def self.with_routes(&block)
+        routes = ActionDispatch::Routing::RouteSet.new
+        routes.draw(&block)
+        include Module.new {
+          define_method(:setup) do
+            super()
+            @routes = routes
+            @controller.singleton_class.include @routes.url_helpers if @controller
+          end
+        }
+        routes
+      end
+    end
+  end
+
+  class TestController < ActionController::Base
+
+    def render_test_view
+      render template: "test_view"
+    end
+  end
+
+  class RenderTest < ActionController::TestCase
+
+    tests TestController
+
+    with_routes do
+      get :render_test_view, to: "test#render_test_view"
+    end
+
+    def setup
+      super
+      @controller.logger      = ActiveSupport::Logger.new(nil)
+      ActionView::Base.logger = ActiveSupport::Logger.new(nil)
+
+      @request.host = "www.scoutapm.com"
+
+      @old_view_paths = ActionController::Base.view_paths
+      ActionController::Base.view_paths = FIXTURE_LOAD_PATH
+    end
+
+    def teardown
+      ActionView::Base.logger = nil
+
+      ActionController::Base.view_paths = @old_view_paths
+    end
+
+    def test_partial_instrumentation
+      recorder = FakeRecorder.new
+      agent_context.recorder = recorder
+
+      instrument = ScoutApm::Instruments::ActionView.new(agent_context)
+      instrument.install(prepend: true)
+
+      get :render_test_view
+      assert_response :success
+
+      root_layer = recorder.requests.first.root_layer
+      children = root_layer.children.to_a
+      assert_equal 2, children.size
+
+      partial_layer = children[0]
+      collection_layer = children[1]
+
+      assert_equal "test_view/Rendering", root_layer.name
+      assert_equal "test/_test_partial/Rendering", partial_layer.name
+      assert_equal "test/_test_partial_collection/Rendering", collection_layer.name
+    end
+  end
+end

data/test/unit/instruments/active_record_test.rb

@@ -24,6 +24,36 @@ class ActiveRecordTest < Minitest::Test
   class User < ActiveRecord::Base
   end
 
+  class DumbRailsConfig
+    def self.after_initialize; end
+  end
+
+  def test_old_rails_initialization
+    recorder = FakeRecorder.new
+    agent_context.recorder = recorder
+    old_rails_version = (1..2).to_a.sample
+    fake_rails(old_rails_version)
+
+    ::Rails.expects(:configuration).never
+
+    instrument = ScoutApm::Instruments::ActiveRecord.new(agent_context)
+    instrument.install(prepend: false)
+    clean_fake_rails
+  end
+
+  def test_modern_rails_initialization
+    recorder = FakeRecorder.new
+    agent_context.recorder = recorder
+    modern_rails_version = (3..7).to_a.sample
+    fake_rails(modern_rails_version)
+
+    ::Rails.expects(:configuration).returns(DumbRailsConfig).once
+
+    instrument = ScoutApm::Instruments::ActiveRecord.new(agent_context)
+    instrument.install(prepend: false)
+    clean_fake_rails
+  end
+
   def test_instrumentation
     recorder = FakeRecorder.new
     agent_context.recorder = recorder

data/test/unit/instruments/fixtures/test/_test_partial.html.erb

@@ -0,0 +1,3 @@
+<div>
+  <p><%= message %></p>
+</div>

data/test/unit/instruments/fixtures/test/_test_partial_collection.html.erb

@@ -0,0 +1,3 @@
+<div>
+  <p><%= index %></p>
+</div>

data/test/unit/instruments/fixtures/test_view.html.erb

@@ -0,0 +1,10 @@
+<html>
+  <head>
+    <title>View</title>
+  </head>
+  <body>
+    <h1>View</h1>
+    <%= render partial: "test_partial", locals: { message: 'Partial' } %>
+    <%= render partial: "test_partial_collection", collection: [1, 2, 3], as: :index %>
+  </body>
+</html>

data/test/unit/sampling_test.rb

@@ -0,0 +1,215 @@
+require 'test_helper'
+
+require 'scout_apm/sampling'
+
+class SamplingTest < Minitest::Test
+
+    def setup
+      @global_sample_config = FakeConfigOverlay.new(
+        {
+          'sample_rate' => 80,
+        }
+      )
+
+      @individual_config = FakeConfigOverlay.new(
+        {
+          'sample_endpoints' => ['/foo/bar:100', '/foo:50', '/bar/zap:80'],
+          'ignore_endpoints' => ['/baz'],
+          'sample_jobs' => ['joba:50'],
+          'ignore_jobs' => 'jobb,jobc',
+        }
+      )
+    end
+
+    def test_individual_sample_to_hash
+      sampling = ScoutApm::Sampling.new(@individual_config)
+      assert_equal({'/foo/bar' => 100, '/foo' => 50, '/bar/zap' => 80}, sampling.individual_sample_to_hash(@individual_config.value('sample_endpoints')))
+
+      sampling = ScoutApm::Sampling.new(@global_sample_config)
+      assert_nil sampling.individual_sample_to_hash(@global_sample_config.value('sample_endpoints'))
+    end
+
+    def test_uri_ignore
+      sampling = ScoutApm::Sampling.new(@individual_config)
+      assert_equal true, sampling.ignore_uri?('/baz/bap')
+      assert_equal false, sampling.ignore_uri?('/foo/far')
+    end
+
+    def test_uri_sample
+      sampling = ScoutApm::Sampling.new(@individual_config)
+      rate = sampling.web_sample_rate('/foo/far')
+      assert_equal 50, rate
+
+      rate = sampling.web_sample_rate('/bar')
+      assert_nil rate
+
+      rate = sampling.web_sample_rate('/baz/bap')
+      assert_nil rate
+
+      rate = sampling.web_sample_rate('/foo/bar/baz')
+      assert_equal 100, rate
+    end
+
+    def test_job_ignore
+      sampling = ScoutApm::Sampling.new(@individual_config)
+      assert_equal true, sampling.ignore_job?('jobb')
+      assert_equal false, sampling.ignore_job?('joba')
+    end
+
+    def test_job_sample
+      sampling = ScoutApm::Sampling.new(@individual_config)
+      assert_equal 50, sampling.job_sample_rate('joba')
+      assert_nil sampling.job_sample_rate('jobb')
+    end
+
+    def test_sample
+      sampling = ScoutApm::Sampling.new(@individual_config)
+      sampling.stub(:rand, 0.01) do
+        assert_equal(false, sampling.sample?(50))
+      end
+      sampling.stub(:rand, 0.99) do
+        assert_equal(true, sampling.sample?(50))
+      end
+    end
+
+    def test_old_ignore
+      config = FakeConfigOverlay.new({'ignore' => ['/foo', '/bar']})
+      sampling = ScoutApm::Sampling.new(config)
+      assert_equal true, sampling.ignore_uri?('/foo')
+      assert_equal true, sampling.ignore_uri?('/bar/bap')
+      assert_equal false, sampling.ignore_uri?('/baz')
+    end
+
+    def test_web_request_individual_sampling
+      sampling = ScoutApm::Sampling.new(@individual_config)
+
+      # should be ignored
+      transaction = FakeTrackedRequest.new_web_request('/baz/bap')
+      assert_equal true, sampling.drop_request?(transaction)
+
+      # should be kept
+      transaction = FakeTrackedRequest.new_web_request('/faz/bap')
+      assert_equal false, sampling.drop_request?(transaction)
+
+      transaction = FakeTrackedRequest.new_web_request('/foo/far')
+      sampling.stub(:rand, 0.01) do
+        assert_equal false, sampling.drop_request?(transaction)
+      end
+
+      # passes individual sample but caught by global rate
+      sampling.stub(:rand, 0.99) do
+        assert_equal true, sampling.drop_request?(transaction)
+      end
+    end
+
+    def test_web_reqeust_general_sampling
+      config = FakeConfigOverlay.new(@individual_config.values.merge({'endpoint_sample_rate' => 80}))
+      sampling = ScoutApm::Sampling.new(config)
+
+      transaction = FakeTrackedRequest.new_web_request('/foo/far')
+      transaction2 = FakeTrackedRequest.new_web_request('/ooo/oar')
+      # /foo/far sampled at 50 specifically, /ooo/oar caught by general endpoint rate of 80
+      sampling.stub(:rand, 0.01) do
+        assert_equal false, sampling.drop_request?(transaction)
+        assert_equal false, sampling.drop_request?(transaction2)
+      end
+
+      sampling.stub(:rand, 0.70) do
+        assert_equal true, sampling.drop_request?(transaction)
+        assert_equal false, sampling.drop_request?(transaction2)
+      end
+
+      sampling.stub(:rand, 0.99) do
+        assert_equal true, sampling.drop_request?(transaction)
+        assert_equal true, sampling.drop_request?(transaction2)
+      end
+    end
+
+    def test_web_request_with_global_sampling
+      config = FakeConfigOverlay.new(@individual_config.values.merge({'sample_rate' => 20}))
+      sampling = ScoutApm::Sampling.new(config)
+
+      # caught by individual rate
+      transaction = FakeTrackedRequest.new_web_request('/foo/far')
+      sampling.stub(:rand, 0.01) do
+        assert_equal false, sampling.drop_request?(transaction)
+      end
+
+      # passes individual rate (50) but caught by global rate (20)
+      sampling.stub(:rand, 0.30) do
+        assert_equal false, sampling.drop_request?(transaction)
+      end
+
+      # passes individual rate
+      sampling.stub(:rand, 0.99) do
+        assert_equal true, sampling.drop_request?(transaction)
+      end
+
+    end
+
+    def test_job_request_individual_sampling
+      sampling = ScoutApm::Sampling.new(@individual_config)
+
+      # should be ignored
+      transaction = FakeTrackedRequest.new_job_request('jobb')
+      assert_equal true, sampling.drop_request?(transaction)
+
+      # should be kept
+      transaction = FakeTrackedRequest.new_job_request('jobz')
+      assert_equal false, sampling.drop_request?(transaction)
+
+      # should be sampled if rand > 50
+      transaction = FakeTrackedRequest.new_job_request('joba')
+      sampling.stub(:rand, 0.01) do
+        assert_equal false, sampling.drop_request?(transaction)
+      end
+
+      sampling.stub(:rand, 0.99) do
+        assert_equal true, sampling.drop_request?(transaction)
+      end
+    end
+
+    def test_job_general_sampling
+      config = FakeConfigOverlay.new(@individual_config.values.merge({'job_sample_rate' => 80}))
+      sampling = ScoutApm::Sampling.new(config)
+
+      transaction = FakeTrackedRequest.new_job_request('joba')
+      transaction2 = FakeTrackedRequest.new_job_request('jobz')
+      # joba sampled at 50 specifically, jobz caught by general job rate of 80
+      sampling.stub(:rand, 0.01) do
+        assert_equal false, sampling.drop_request?(transaction)
+        assert_equal false, sampling.drop_request?(transaction2)
+      end
+
+      sampling.stub(:rand, 0.70) do
+        assert_equal true, sampling.drop_request?(transaction)
+        assert_equal false, sampling.drop_request?(transaction2)
+      end
+
+      sampling.stub(:rand, 0.99) do
+        assert_equal true, sampling.drop_request?(transaction)
+        assert_equal true, sampling.drop_request?(transaction2)
+      end
+    end
+
+    def test_job_request_global_sampling
+      config = FakeConfigOverlay.new(@individual_config.values.merge({'sample_rate' => 20}))
+      sampling = ScoutApm::Sampling.new(config)
+
+      # caught by individual rate
+      transaction = FakeTrackedRequest.new_job_request('joba')
+      sampling.stub(:rand, 0.01) do
+        assert_equal false, sampling.drop_request?(transaction)
+      end
+
+      # passes individual rate (50) but caught by global rate (20)
+      sampling.stub(:rand, 0.30) do
+        assert_equal false, sampling.drop_request?(transaction)
+      end
+
+      # passes individual rate
+      sampling.stub(:rand, 0.99) do
+        assert_equal true, sampling.drop_request?(transaction)
+      end
+    end
+end