scout_apm 5.7.1 → 6.0.0

data/test/unit/auto_instrument/controller-instrumented.rb

@@ -10,40 +10,65 @@ class ClientsController < ApplicationController
     end
   end
 
+  def new
+    ::ScoutApm::AutoInstrument("super do |something|...",["ROOT/test/unit/auto_instrument/controller.rb:14:in `new'"]){super do |something|
+      @client = Client.new
+    end}
+  end
+
   def create
-    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["ROOT/test/unit/auto_instrument/controller.rb:14:in `create'"]){Client.new(params[:client])}
-    if ::ScoutApm::AutoInstrument("@client.save",["ROOT/test/unit/auto_instrument/controller.rb:15:in `create'"]){@client.save}
-      ::ScoutApm::AutoInstrument("redirect_to @client",["ROOT/test/unit/auto_instrument/controller.rb:16:in `create'"]){redirect_to @client}
+    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["ROOT/test/unit/auto_instrument/controller.rb:20:in `create'"]){Client.new(params[:client])}
+    if ::ScoutApm::AutoInstrument("@client.save",["ROOT/test/unit/auto_instrument/controller.rb:21:in `create'"]){@client.save}
+      ::ScoutApm::AutoInstrument("redirect_to @client",["ROOT/test/unit/auto_instrument/controller.rb:22:in `create'"]){redirect_to @client}
     else
       # This line overrides the default rendering behavior, which
       # would have been to render the "create" view.
-      ::ScoutApm::AutoInstrument("render \"new\"",["ROOT/test/unit/auto_instrument/controller.rb:20:in `create'"]){render "new"}
+      ::ScoutApm::AutoInstrument("render \"new\"",["ROOT/test/unit/auto_instrument/controller.rb:26:in `create'"]){render "new"}
     end
   end
 
   def edit
-    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["ROOT/test/unit/auto_instrument/controller.rb:25:in `edit'"]){Client.new(params[:client])}
+    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["ROOT/test/unit/auto_instrument/controller.rb:31:in `edit'"]){Client.new(params[:client])}
 
-    if ::ScoutApm::AutoInstrument("request.post?",["ROOT/test/unit/auto_instrument/controller.rb:27:in `edit'"]){request.post?}
-      ::ScoutApm::AutoInstrument("@client.transaction do...",["ROOT/test/unit/auto_instrument/controller.rb:28:in `edit'"]){@client.transaction do
+    if ::ScoutApm::AutoInstrument("request.post?",["ROOT/test/unit/auto_instrument/controller.rb:33:in `edit'"]){request.post?}
+      ::ScoutApm::AutoInstrument("@client.transaction do...",["ROOT/test/unit/auto_instrument/controller.rb:34:in `edit'"]){@client.transaction do
         @client.update_attributes(params[:client])
       end}
     end
   end
 
   def data
-    @clients = ::ScoutApm::AutoInstrument("Client.all",["ROOT/test/unit/auto_instrument/controller.rb:35:in `data'"]){Client.all}
+    @clients = ::ScoutApm::AutoInstrument("Client.all",["ROOT/test/unit/auto_instrument/controller.rb:41:in `data'"]){Client.all}
 
-    formatter = ::ScoutApm::AutoInstrument("proc do |row|...",["ROOT/test/unit/auto_instrument/controller.rb:37:in `data'"]){proc do |row|
+    formatter = ::ScoutApm::AutoInstrument("proc do |row|...",["ROOT/test/unit/auto_instrument/controller.rb:43:in `data'"]){proc do |row|
       row.to_json
     end}
 
-    ::ScoutApm::AutoInstrument("respond_with @clients.each(&formatter).join(\"\\n\"), :content_type => 'application/json; boundary=NL'",["ROOT/test/unit/auto_instrument/controller.rb:41:in `data'"]){respond_with @clients.each(&formatter).join("\n"), :content_type => 'application/json; boundary=NL'}
+    ::ScoutApm::AutoInstrument("respond_with @clients.each(&formatter).join(\"\\n\"), :content_type => 'application/json; boundary=NL'",["ROOT/test/unit/auto_instrument/controller.rb:47:in `data'"]){respond_with @clients.each(&formatter).join("\n"), :content_type => 'application/json; boundary=NL'}
   end
   
   def things
     x = {}
     x[:this] ||= 'foo'
-    x[:that] &&= ::ScoutApm::AutoInstrument("'foo'.size",["ROOT/test/unit/auto_instrument/controller.rb:47:in `things'"]){'foo'.size}
+    x[:that] &&= ::ScoutApm::AutoInstrument("'foo'.size",["ROOT/test/unit/auto_instrument/controller.rb:53:in `things'"]){'foo'.size}
+  end
+
+  def do_something
+    ::ScoutApm::AutoInstrument("wrap_call(\"123\",...",["ROOT/test/unit/auto_instrument/controller.rb:57:in `do_something'"]){wrap_call("123",
+              something: -> { puts "Do something" }
+            ) do
+
+      raw_data = '{ "key": "123" }'
+
+      payload = begin
+                  Marshal.load(raw_data)
+                rescue
+                  puts 'Failed with bad/unhelpful error message'
+                end
+    end}
+  end
+
+  def wrap_call(*args, **kwargs)
+    yield
   end
 end

data/test/unit/auto_instrument/controller.rb

@@ -10,6 +10,12 @@ class ClientsController < ApplicationController
     end
   end
 
+  def new
+    super do |something|
+      @client = Client.new
+    end
+  end
+
   def create
     @client = Client.new(params[:client])
     if @client.save
@@ -46,4 +52,23 @@ class ClientsController < ApplicationController
     x[:this] ||= 'foo'
     x[:that] &&= 'foo'.size
   end
+
+  def do_something
+    wrap_call("123",
+              something: -> { puts "Do something" }
+            ) do
+
+      raw_data = '{ "key": "123" }'
+
+      payload = begin
+                  Marshal.load(raw_data)
+                rescue
+                  puts 'Failed with bad/unhelpful error message'
+                end
+    end
+  end
+
+  def wrap_call(*args, **kwargs)
+    yield
+  end
 end

data/test/unit/auto_instrument/hash_shorthand_controller-instrumented.rb

@@ -1,28 +1,46 @@
 
 class HashShorthandController < ApplicationController
   def hash
+    ::ScoutApm::AutoInstrument("THREAD.current[:ternary_check] = true",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:4:in `hash'"]){THREAD.current[:ternary_check] = true}
     json = {
       static: "static",
-      shorthand: ::ScoutApm::AutoInstrument("shorthand:",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:6:in `hash'"]){shorthand},
-      longhand: ::ScoutApm::AutoInstrument("longhand: longhand",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:7:in `hash'"]){longhand},
-      longhand_different_key: ::ScoutApm::AutoInstrument("longhand",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:8:in `hash'"]){longhand},
-      hash_rocket: ::ScoutApm::AutoInstrument(":hash_rocket => hash_rocket",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:9:in `hash'"]){hash_rocket},
-      :hash_rocket_different_key => ::ScoutApm::AutoInstrument("hash_rocket",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:10:in `hash'"]){hash_rocket},
-      non_nil_receiver: ::ScoutApm::AutoInstrument("non_nil_receiver.value",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:11:in `hash'"]){non_nil_receiver.value},
+      shorthand: ::ScoutApm::AutoInstrument("shorthand:",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:7:in `hash'"]){shorthand},
+      longhand: ::ScoutApm::AutoInstrument("longhand: longhand",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:8:in `hash'"]){longhand},
+      longhand_different_key: ::ScoutApm::AutoInstrument("longhand",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:9:in `hash'"]){longhand},
+      hash_rocket: ::ScoutApm::AutoInstrument(":hash_rocket => hash_rocket",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:10:in `hash'"]){hash_rocket},
+      :hash_rocket_different_key => ::ScoutApm::AutoInstrument("hash_rocket",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:11:in `hash'"]){hash_rocket},
+      non_nil_receiver: ::ScoutApm::AutoInstrument("non_nil_receiver.value",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:12:in `hash'"]){non_nil_receiver.value},
       nested: {
-        shorthand: ::ScoutApm::AutoInstrument("shorthand:",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:13:in `hash'"]){shorthand},
+        shorthand: ::ScoutApm::AutoInstrument("shorthand:",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:14:in `hash'"]){shorthand},
       },
-      nested_call: ::ScoutApm::AutoInstrument("nested_call(params[\"timestamp\"])",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:15:in `hash'"]){nested_call(params["timestamp"])}
+      nested_call: ::ScoutApm::AutoInstrument("nested_call(params[\"timestamp\"])",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:16:in `hash'"]){nested_call(params["timestamp"])},
+      nested_with_ternaries: {
+                            truthy: ::ScoutApm::AutoInstrument("THREAD.current[:ternary_check] == true",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:18:in `hash'"]){THREAD.current[:ternary_check] == true} ? 1 : 0,
+                            falsy: ::ScoutApm::AutoInstrument("THREAD.current[:ternary_check] == false",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:19:in `hash'"]){THREAD.current[:ternary_check] == false} ? 1 : 0,
+                          },
+      ternary: ::ScoutApm::AutoInstrument("ternary",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:21:in `hash'"]){ternary} ? ::ScoutApm::AutoInstrument("ternary",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:21:in `hash'"]){ternary} : nil,
     }
-    ::ScoutApm::AutoInstrument("render json:",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:17:in `hash'"]){render json:}
+    ::ScoutApm::AutoInstrument("render json:",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:23:in `hash'"]){render json:}
   end
 
   private
 
+  def simple_method
+    "simple"
+  end
+
+  def inner_method
+    "inner"
+  end
+
   def nested_call(noop)
     noop
   end
 
+  def ternary
+    true
+  end
+
   def shorthand
     "shorthand"
   end
@@ -36,6 +54,6 @@ class HashShorthandController < ApplicationController
   end
 
   def non_nil_receiver
-    ::ScoutApm::AutoInstrument("OpenStruct.new(value: \"value\")",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:39:in `non_nil_receiver'"]){OpenStruct.new(value: "value")}
+    ::ScoutApm::AutoInstrument("OpenStruct.new(value: \"value\")",["ROOT/test/unit/auto_instrument/hash_shorthand_controller.rb:57:in `non_nil_receiver'"]){OpenStruct.new(value: "value")}
   end
 end

data/test/unit/auto_instrument/hash_shorthand_controller.rb

@@ -1,6 +1,7 @@
 
 class HashShorthandController < ApplicationController
   def hash
+    THREAD.current[:ternary_check] = true
     json = {
       static: "static",
       shorthand:,
@@ -12,17 +13,34 @@ class HashShorthandController < ApplicationController
       nested: {
         shorthand:,
       },
-      nested_call: nested_call(params["timestamp"])
+      nested_call: nested_call(params["timestamp"]),
+      nested_with_ternaries: {
+                            truthy: THREAD.current[:ternary_check] == true ? 1 : 0,
+                            falsy: THREAD.current[:ternary_check] == false ? 1 : 0,
+                          },
+      ternary: ternary ? ternary : nil,
     }
     render json:
   end
 
   private
 
+  def simple_method
+    "simple"
+  end
+
+  def inner_method
+    "inner"
+  end
+
   def nested_call(noop)
     noop
   end
 
+  def ternary
+    true
+  end
+
   def shorthand
     "shorthand"
   end

data/test/unit/auto_instrument_test.rb

@@ -1,3 +1,8 @@
+begin
+  require 'prism'
+rescue LoadError
+end
+
 require 'test_helper'
 
 require 'scout_apm/auto_instrument'
@@ -21,7 +26,8 @@ class AutoInstrumentTest < Minitest::Test
   # test controller.rb file, which will be different on different environments.
   # This normalizes backtraces across environments.
   def normalize_backtrace(string)
-    string.gsub(ROOT, "ROOT")
+    # Keep tests simple and just use UTF-8 encoding.
+    result = string.gsub(ROOT, "ROOT").force_encoding("UTF-8")
   end
 
   # Use this to automatically update the test fixtures.

data/test/unit/background_job_integrations/faktory_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require 'scout_apm/background_job_integrations/faktory'
+
+class FaktoryTest < Minitest::Test
+  FaktoryMiddleware = ScoutApm::BackgroundJobIntegrations::FaktoryMiddleware
+
+  def test_middleware_call_job_exception_with_error_monitoring
+    # Test that error buffer is called on exception
+    fake_request = mock
+    fake_request.expects(:annotate_request)
+    fake_request.expects(:start_layer).twice
+    fake_request.expects(:stop_layer).twice
+    fake_request.expects(:error!)
+
+    fake_context = mock
+    fake_error_buffer = mock
+    fake_context.expects(:error_buffer).returns(fake_error_buffer)
+    
+    expected_env = {
+      :custom_controller => "TestJob",
+      :custom_action => "critical"
+    }
+    fake_error_buffer.expects(:capture).with(kind_of(RuntimeError), expected_env)
+
+    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
+    ScoutApm::Agent.instance.expects(:context).returns(fake_context)
+
+    worker_instance = mock
+    job = {
+      "queue" => "critical",
+      "jobtype" => "TestJob",
+      "enqueued_at" => Time.now.iso8601
+    }
+
+    assert_raises RuntimeError do
+      FaktoryMiddleware.new.call(worker_instance, job) do
+        raise RuntimeError, "Job failed"
+      end
+    end
+  end
+
+  def test_middleware_call_activejob_wrapper
+    # Test ActiveJob job class extraction
+    fake_request = mock
+    fake_request.expects(:annotate_request)
+    fake_request.expects(:start_layer).twice
+    fake_request.expects(:stop_layer).twice
+    fake_request.expects(:error!)
+
+    fake_context = mock
+    fake_error_buffer = mock
+    fake_context.expects(:error_buffer).returns(fake_error_buffer)
+    
+    expected_env = {
+      :custom_controller => "MyRealJob",  # Should extract from custom.wrapped
+      :custom_action => "default"
+    }
+    fake_error_buffer.expects(:capture).with(kind_of(RuntimeError), expected_env)
+
+    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
+    ScoutApm::Agent.instance.expects(:context).returns(fake_context)
+
+    # ActiveJob wrapper scenario
+    worker_instance = mock
+    job = {
+      "queue" => "default", 
+      "jobtype" => "ActiveJob::QueueAdapters::FaktoryAdapter::JobWrapper",
+      "custom" => { "wrapped" => "MyRealJob" },
+      "created_at" => Time.now.iso8601
+    }
+
+    assert_raises RuntimeError do
+      FaktoryMiddleware.new.call(worker_instance, job) do
+        raise RuntimeError, "ActiveJob failed"
+      end
+    end
+  end
+
+  def test_middleware_call_missing_queue_fallback
+    # Test behavior when queue is missing
+    fake_request = mock
+    fake_request.expects(:annotate_request)
+    fake_request.expects(:start_layer).twice
+    fake_request.expects(:stop_layer).twice
+    fake_request.expects(:error!)
+
+    fake_context = mock
+    fake_error_buffer = mock
+    fake_context.expects(:error_buffer).returns(fake_error_buffer)
+    
+    expected_env = {
+      :custom_controller => "UnknownJob",  # Fallback when jobtype missing
+      :custom_action => nil  # No queue
+    }
+    fake_error_buffer.expects(:capture).with(kind_of(RuntimeError), expected_env)
+
+    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
+    ScoutApm::Agent.instance.expects(:context).returns(fake_context)
+
+    worker_instance = mock
+    job = {}  # Empty job data
+
+    assert_raises RuntimeError do
+      FaktoryMiddleware.new.call(worker_instance, job) do
+        raise RuntimeError, "Job failed"
+      end
+    end
+  end
+end

data/test/unit/background_job_integrations/shoryuken_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+require 'scout_apm/background_job_integrations/shoryuken'
+
+class ShoryukenTest < Minitest::Test
+  ShoryukenIntegration = ScoutApm::BackgroundJobIntegrations::Shoryuken
+  ShoryukenMiddleware = ScoutApm::BackgroundJobIntegrations::ShoryukenMiddleware
+
+  def test_middleware_call_job_exception_with_error_monitoring
+    # Test that error buffer is called on exception
+    fake_request = mock
+    fake_request.expects(:annotate_request)
+    fake_request.expects(:start_layer).twice
+    fake_request.expects(:stop_layer).twice  
+    fake_request.expects(:error!)
+
+    fake_context = mock
+    fake_error_buffer = mock
+    fake_context.expects(:error_buffer).returns(fake_error_buffer)
+    
+    expected_env = {
+      :custom_controller => "TestWorker",
+      :custom_action => "test-queue"
+    }
+    fake_error_buffer.expects(:capture).with(kind_of(RuntimeError), expected_env)
+
+    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
+    ScoutApm::Agent.instance.expects(:context).returns(fake_context)
+
+    worker_instance = mock
+    mock_class = mock
+    mock_class.expects(:to_s).twice.returns("TestWorker")
+    worker_instance.expects(:class).twice.returns(mock_class)
+    queue = "test-queue"
+    msg = mock
+    msg.expects(:attributes).returns({'SentTimestamp' => '1534873927868'})
+    body = {}
+
+    assert_raises RuntimeError do
+      ShoryukenMiddleware.new.call(worker_instance, queue, msg, body) do
+        raise RuntimeError, "Job failed"
+      end
+    end
+  end
+
+  def test_middleware_call_activejob_wrapper
+    # Test ActiveJob job class extraction
+    fake_request = mock
+    fake_request.expects(:annotate_request)
+    fake_request.expects(:start_layer).twice
+    fake_request.expects(:stop_layer).twice
+    fake_request.expects(:error!)
+
+    fake_context = mock
+    fake_error_buffer = mock
+    fake_context.expects(:error_buffer).returns(fake_error_buffer)
+    
+    expected_env = {
+      :custom_controller => "MyRealJob",  # Should extract from body
+      :custom_action => "priority-queue"
+    }
+    fake_error_buffer.expects(:capture).with(kind_of(RuntimeError), expected_env)
+
+    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
+    ScoutApm::Agent.instance.expects(:context).returns(fake_context)
+
+    worker_instance = mock
+    mock_class = mock
+    mock_class.expects(:to_s).returns("ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper")
+    worker_instance.expects(:class).returns(mock_class)
+    queue = "priority-queue"
+    msg = mock
+    msg.expects(:attributes).returns({'SentTimestamp' => '1534873927868'})
+    body = { "job_class" => "MyRealJob" }
+
+    assert_raises RuntimeError do
+      ShoryukenMiddleware.new.call(worker_instance, queue, msg, body) do
+        raise RuntimeError, "ActiveJob failed"
+      end
+    end
+  end
+end

data/test/unit/background_job_integrations/sidekiq_test.rb

@@ -125,4 +125,42 @@ class SidekiqTest < Minitest::Test
     msg = {}
     assert_equal 0, SidekiqMiddleware.new.latency(msg, 200)
   end
+
+  ########################################
+  # Job Arguments Capture
+  ########################################
+  def test_capture_job_args_when_enabled_with_valid_job
+    test_job_class = Class.new do
+      def self.name
+        'TestJobWithArgs'
+      end
+
+      def perform(user_id, email, filter_param, dict_val)
+      end
+    end
+
+    Object.const_set('TestJobWithArgs', test_job_class)
+
+    SidekiqMiddleware.any_instance.stubs(:capture_job_args?).returns(true)
+    SidekiqMiddleware.any_instance.stubs(:filtered_params_config).returns(["filter_param"])
+
+    fake_request = mock
+    fake_request.expects(:annotate_request)
+    fake_request.expects(:start_layer).twice
+    fake_request.expects(:stop_layer).twice
+
+    ScoutApm::RequestManager.stubs(:lookup).returns(fake_request)
+    ScoutApm::Context.expects(:add).with({ user_id: 123, email: 'test@example.com', filter_param: '[FILTERED]', dict_val: '[UNSUPPORTED TYPE]' })
+
+    msg = {
+      'class' => 'TestJobWithArgs',
+      'args' => [{ 'arguments' => [123, 'test@example.com', 'secret', {a: 1}] }]
+    }
+
+    block_called = false
+    SidekiqMiddleware.new.call(nil, msg, "defaultqueue") { block_called = true }
+    assert block_called
+
+    Object.send(:remove_const, 'TestJobWithArgs')
+  end
 end

data/test/unit/config_test.rb

@@ -92,6 +92,20 @@ class ConfigTest < Minitest::Test
     assert_nil coercion.coerce(nil)
   end
 
+  def test_sample_rate_coercion
+    coercion = ScoutApm::Config::SampleRateCoercion.new
+    assert_in_delta 1.0, coercion.coerce("1")
+    assert_in_delta 0.015, coercion.coerce("1.5")
+    assert_in_delta 1.0, coercion.coerce(1)
+    assert_in_delta 0.015, coercion.coerce(1.5)
+    assert_in_delta 0.0, coercion.coerce("0")
+    assert_in_delta 0.0, coercion.coerce(0)
+    assert_in_delta 0.0, coercion.coerce("")
+    assert_in_delta 0.0, coercion.coerce(nil)
+    assert_in_delta 0.5, coercion.coerce("0.5")
+    assert_in_delta 0, coercion.coerce("-2.5")
+  end
+
   def test_any_keys_found
     ENV.stubs(:has_key?).returns(nil)
 

data/test/unit/error_service/error_buffer_test.rb

@@ -25,6 +25,7 @@ class ErrorBufferTest < Minitest::Test
 
       exception = exceptions[0]
       expected_env_keys = [
+        "REQUEST_METHOD",
         "ANOTHER_HEADER",
         "HTTP_X_FORWARDED_FOR",
         "HTTP_USER_AGENT",
@@ -67,4 +68,35 @@ class ErrorBufferTest < Minitest::Test
   def ex(msg="Whoops")
     FakeError.new(msg)
   end
+
+  def test_user_context_is_flattened_with_user_prefix
+    config = make_fake_config(
+      'errors_enabled' => true,
+      'errors_env_capture' => %w()
+    )
+    test_context = ScoutApm::AgentContext.new().tap { |c| c.config = config }
+    
+    ScoutApm::Agent.instance.stub(:context, test_context) do
+      eb = ScoutApm::ErrorService::ErrorBuffer.new(test_context)
+      
+      # Set user context using add_user
+      ScoutApm::Context.add_user(id: 2)
+      # Set extra context using add
+      ScoutApm::Context.add(organization: 3)
+      
+      eb.capture(ex, env)
+      exceptions = eb.instance_variable_get(:@error_records)
+      
+      assert_equal 1, exceptions.length
+      exception = exceptions[0]
+      
+      # User context should be flattened with "user_" prefix
+      assert_equal 2, exception.context["user_id"]
+      # Extra context should remain as-is
+      assert_equal 3, exception.context[:organization]
+      
+      # Should NOT have nested :user key
+      refute exception.context.key?(:user)
+    end
+  end
 end

data/test/unit/error_test.rb

@@ -55,7 +55,7 @@ class ErrorTest < Minitest::Test
 
       assert_equal "No context or env", exceptions[3].message
       assert_equal "AnotherError", exceptions[3].exception_class
-      assert_equal assert_empty_context, exceptions[3].context
+      assert_equal assert_default_context, exceptions[3].context
 
       assert_equal "Whoops", exceptions[4].message
       assert_equal "ErrorTest::FakeError", exceptions[4].exception_class
@@ -84,8 +84,8 @@ class ErrorTest < Minitest::Test
     }
   end
 
-  def assert_empty_context
-    {user: {}}
+  def assert_default_context
+    {transaction_id: ScoutApm::RequestManager.lookup.transaction_id}
   end
 
   def ex(msg="Whoops")

data/test/unit/ignored_uris_test.rb

@@ -19,4 +19,11 @@ class IgnoredUrlsTest < Minitest::Test
     assert_equal false, i.ignore?("/users/2/health")
     assert_equal true, i.ignore?("/admin/dashboard")
   end
+
+  def test_ignores_prefix_regex
+    i = ScoutApm::IgnoredUris.new(["/slow/\\d+/notifications", "/health"])
+    assert_equal true, i.ignore?("/slow/123/notifications")
+    assert_equal false, i.ignore?("/slow/abcd/notifications")
+    assert_equal true, i.ignore?("/health")
+  end
 end

data/test/unit/instruments/http_client_test.rb

@@ -3,8 +3,6 @@ if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
 
   require 'scout_apm/instruments/http_client'
 
-  require 'httpclient'
-
   class HttpClientTest < Minitest::Test
     def setup
       @context = ScoutApm::AgentContext.new

data/test/unit/instruments/httpx_test.rb

@@ -0,0 +1,78 @@
+if (ENV["SCOUT_TEST_FEATURES"] || "").include?("instruments")
+  require 'test_helper'
+
+  require 'scout_apm/instruments/httpx'
+
+  require 'httpx'
+
+  class HTTPXTest < Minitest::Test
+    def setup
+      @context = ScoutApm::AgentContext.new
+      @recorder = FakeRecorder.new
+      ScoutApm::Agent.instance.context.recorder = @recorder
+      ScoutApm::Instruments::HTTPX.new(@context).install(prepend: false)
+    end
+
+
+    def test_httpx
+      responses = HTTPX.get(
+        "https://news.ycombinator.com/news",
+        "https://news.ycombinator.com/news?p=2",
+        "https://google.com/q=me"
+      )
+
+      assert_equal 1, @recorder.requests.length
+
+      assert_recorded(@recorder, "HTTP", "GET", "3 requests")
+    end
+
+    def test_httpx_post_request
+      HTTPX.post("https://httpbin.org/post", json: { test: "data" })
+      assert_recorded(@recorder, "HTTP", "POST", "httpbin.org/post")
+    end
+
+    def test_instruments_httpx_error_handling
+      begin
+        HTTPX.get("https://thisshouldnotexistatall12345.com")
+      rescue
+      end
+
+      assert_equal 1, @recorder.requests.length
+    end
+
+    def test_httpx_request_retry
+      begin
+        HTTPX.with(timeout: { connect_timeout: 0.25, request_timeout: 0.25 })
+             .get("https://httpbin.org/delay/5")
+      rescue
+      end
+      assert_equal 1, @recorder.requests.length
+    end
+
+    def test_multiple_plugins
+      session = HTTPX.plugin(:persistent).plugin(:follow_redirects)
+
+      session.get("https://news.ycombinator.com/news")
+      begin
+        session.get("http://httpbin.org/redirect/2")
+      rescue
+        skip "httpbin.org not available"
+      end
+
+      assert_equal 2, @recorder.requests.length, "Expected 2 requests to be recorded"
+    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
+      if !desc.nil?
+        assert req.root_layer.desc.include?(desc),
+          "Expected description to include '#{desc}', got '#{req.root_layer.desc}'"
+      end
+    end
+  end
+end