scout_apm 4.0.4 → 5.0.0

data/lib/scout_apm/layer_converters/external_service_converter.rb

@@ -0,0 +1,65 @@
+module ScoutApm
+  module LayerConverters
+    class ExternalServiceConverter < ConverterBase
+      def initialize(*)
+        super
+        @external_service_metric_set = ExternalServiceMetricSet.new(context)
+      end
+
+      def register_hooks(walker)
+        super
+
+        return unless scope_layer
+
+        walker.on do |layer|
+          next if skip_layer?(layer)
+          stat = ExternalServiceMetricStats.new(
+            domain_name(layer),
+            operation_name(layer),          # operation name/verb. GET/POST/PUT etc.
+            scope_layer.legacy_metric_name, # controller_scope
+            1,                              # count, this is a single call, so 1
+            layer.total_call_time
+          )
+          @external_service_metric_set << stat
+        end
+      end
+
+      def record!
+        # Everything in the metric set here is from a single transaction, which
+        # we want to keep track of. (One web call did a User#find 10 times, but
+        # only due to 1 http request)
+        @external_service_metric_set.increment_transaction_count!
+        @store.track_external_service_metrics!(@external_service_metric_set)
+
+        nil # not returning anything in the layer results ... not used
+      end
+
+      def skip_layer?(layer)
+        layer.type != 'HTTP' ||
+          layer.limited? ||
+          super
+      end
+
+      private
+
+      # If we can't name the domain name, default to:
+      DEFAULT_DOMAIN = "Unknown"
+
+      def domain_name(layer)
+        domain = ""
+        desc_str = layer.desc.to_s
+        desc_str = 'http://' + desc_str unless desc_str =~ /^http/i
+        domain = URI.parse(desc_str).host
+      rescue
+        # Do nothing
+      ensure
+        domain = DEFAULT_DOMAIN if domain.to_s.blank?
+        domain
+      end
+
+      def operation_name(layer)
+        "all" # Hardcode to "all" until we support breakout by verb
+      end
+    end
+  end
+end

data/lib/scout_apm/layer_converters/find_layer_by_type.rb

@@ -5,6 +5,10 @@
 #       show
 #       render :update
 #     end
+
+# This doesn't cache the negative result when searching for a controller / job,
+# so that we can ask again later after more of the request has occurred and
+# correctly find it.
 module ScoutApm
   module LayerConverters
     class FindLayerByType

data/lib/scout_apm/layer_converters/request_queue_time_converter.rb

@@ -11,6 +11,8 @@ module ScoutApm
       def record!
         return unless request.web?
 
+        return unless context.config.value('record_queue_time')
+
         return unless headers
 
         raw_start = locate_timestamp

data/lib/scout_apm/logger.rb

@@ -69,14 +69,14 @@ module ScoutApm
     private
 
     def build_logger
-      logger_class.new(@log_destination)
+      logger_class.new(@log_destination) rescue logger_class.new
     end
 
     def logger_class
       klass = @opts.fetch(:logger_class, ::Logger)
       case klass
       when String
-        result = KlassHelper.lookup(klass)
+        result = Utils::KlassHelper.lookup(klass)
         if result == :missing_class
           ::Logger
         else

data/lib/scout_apm/reporting.rb

@@ -83,11 +83,12 @@ module ScoutApm
       slow_jobs = reporting_period.slow_jobs_payload
       histograms = reporting_period.histograms
       db_query_metrics = reporting_period.db_query_metrics_payload
+      external_service_metrics = reporting_period.external_service_metrics_payload
       traces = (slow_transactions.map(&:span_trace) + slow_jobs.map(&:span_trace)).compact
 
       log_deliver(metrics, slow_transactions, metadata, slow_jobs, histograms)
 
-      payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, traces)
+      payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, external_service_metrics, traces)
       logger.debug("Sending payload w/ Headers: #{headers.inspect}")
 
       reporter.report(payload, headers)

data/lib/scout_apm/serializers/external_service_serializer_to_json.rb

@@ -0,0 +1,15 @@
+module ScoutApm
+  module Serializers
+    class ExternalServiceSerializerToJson
+      attr_reader :external_service_metrics
+
+      def initialize(external_service_metrics)
+        @external_service_metrics = external_service_metrics
+      end
+
+      def as_json
+        external_service_metrics.map{|metric| metric.as_json }
+      end
+    end
+  end
+end

data/lib/scout_apm/serializers/payload_serializer.rb

@@ -2,9 +2,9 @@
 module ScoutApm
   module Serializers
     class PayloadSerializer
-      def self.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, traces)
+      def self.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, external_service_metrics, traces)
         if ScoutApm::Agent.instance.context.config.value("report_format") == 'json'
-          ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, traces)
+          ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, external_service_metrics, traces)
         else
           metadata = metadata.dup
           metadata.default = nil
@@ -22,7 +22,8 @@ module ScoutApm
                        # payloads. At this point, the marshal code branch is
                        # very rarely used anyway.
                        :histograms        => HistogramsSerializerToJson.new(histograms).as_json,
-                       :db_query_metrics  => db_query_metrics)
+                       :db_query_metrics  => db_query_metrics,
+                       :external_service_metrics  => external_service_metrics)
         end
       end
 

data/lib/scout_apm/serializers/payload_serializer_to_json.rb

@@ -2,7 +2,7 @@ module ScoutApm
   module Serializers
     module PayloadSerializerToJson
       class << self
-        def serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, traces)
+        def serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, external_service_metrics, traces)
           metadata.merge!({:payload_version => 2})
 
           jsonify_hash({:metadata => metadata,
@@ -14,6 +14,9 @@ module ScoutApm
                         :db_metrics => {
                           :query => DbQuerySerializerToJson.new(db_query_metrics).as_json,
                         },
+                        :es_metrics => {
+                          :http => ExternalServiceSerializerToJson.new(external_service_metrics).as_json,
+                        },
                         :span_traces => traces.map{ |t| t.as_json },
           })
         end

data/lib/scout_apm/store.rb

@@ -52,6 +52,13 @@ module ScoutApm
       }
     end
 
+    def track_external_service_metrics!(external_service_metric_set, options={})
+      @mutex.synchronize {
+        period = find_period(options[:timestamp])
+        period.merge_external_service_metrics!(external_service_metric_set)
+      }
+    end
+
     def track_one!(type, name, value, options={})
       meta = MetricMeta.new("#{type}/#{name}")
       stat = MetricStats.new(false)
@@ -206,6 +213,8 @@ module ScoutApm
 
     attr_reader :db_query_metric_set
 
+    attr_reader :external_service_metric_set
+
     def initialize(timestamp, context)
       @timestamp = timestamp
 
@@ -216,6 +225,7 @@ module ScoutApm
 
       @metric_set = MetricSet.new
       @db_query_metric_set = DbQueryMetricSet.new(context)
+      @external_service_metric_set = ExternalServiceMetricSet.new(context)
 
       @jobs = Hash.new
     end
@@ -228,7 +238,8 @@ module ScoutApm
         merge_jobs!(other.jobs).
         merge_slow_jobs!(other.slow_jobs_payload).
         merge_histograms!(other.histograms).
-        merge_db_query_metrics!(other.db_query_metric_set)
+        merge_db_query_metrics!(other.db_query_metric_set).
+        merge_external_service_metrics!(other.external_service_metric_set)
       self
     end
 
@@ -254,6 +265,11 @@ module ScoutApm
       self
     end
 
+    def merge_external_service_metrics!(other_metric_set)
+      external_service_metric_set.combine!(other_metric_set)
+      self
+    end
+
     def merge_slow_transactions!(new_transactions)
       Array(new_transactions).each do |one_transaction|
         request_traces << one_transaction
@@ -316,6 +332,10 @@ module ScoutApm
       db_query_metric_set.metrics_to_report
     end
 
+    def external_service_metrics_payload
+      external_service_metric_set.metrics_to_report
+    end
+
     #################################
     # Debug Helpers
     #################################

data/lib/scout_apm/tracked_request.rb

@@ -117,7 +117,12 @@ module ScoutApm
       # Must follow layer.record_stop_time! as the total_call_time is used to determine if the layer is significant.
       return if layer_insignificant?(layer)
 
-      @layers[-1].add_child(layer) if @layers.any?
+      # Check that the parent exists before calling a method on it, since some threading can get us into a weird state.
+      # this doesn't fix that state, but prevents exceptions from leaking out.
+      parent = @layers[-1]
+      if parent
+        parent.add_child(layer)
+      end
 
       # This must be called before checking if a backtrace should be collected as the call count influences our capture logic.
       # We call `#update_call_counts in stop layer to ensure the layer has a final desc. Layer#desc is updated during the AR instrumentation flow.
@@ -315,6 +320,7 @@ module ScoutApm
         :queue_time => LayerConverters::RequestQueueTimeConverter,
         :job => LayerConverters::JobConverter,
         :db => LayerConverters::DatabaseConverter,
+        :external_service => LayerConverters::ExternalServiceConverter,
 
         :slow_job => LayerConverters::SlowJobConverter,
         :slow_req => LayerConverters::SlowRequestConverter,

data/lib/scout_apm/utils/sql_sanitizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: false
+
 require 'scout_apm/environment'
 
 # Removes actual values from SQL. Used to both obfuscate the SQL and group
@@ -5,12 +7,34 @@ require 'scout_apm/environment'
 module ScoutApm
   module Utils
     class SqlSanitizer
-      if ScoutApm::Environment.instance.ruby_187?
-        require 'scout_apm/utils/sql_sanitizer_regex_1_8_7'
-      else
-        require 'scout_apm/utils/sql_sanitizer_regex'
-      end
-      include ScoutApm::Utils::SqlRegex
+      MULTIPLE_SPACES    = %r|\s+|.freeze
+      MULTIPLE_QUESTIONS = /\?(,\?)+/.freeze
+
+      PSQL_VAR_INTERPOLATION = %r|\[\[.*\]\]\s*\z|.freeze
+      PSQL_REMOVE_STRINGS = /'(?:[^']|'')*'/.freeze
+      PSQL_REMOVE_INTEGERS = /(?<!LIMIT )\b\d+\b/.freeze
+      PSQL_AFTER_SELECT = /(?:SELECT\s+).*?(?:WHERE|FROM\z)/im.freeze # Should be everything between a FROM and a WHERE
+      PSQL_PLACEHOLDER = /\$\d+/.freeze
+      PSQL_IN_CLAUSE = /IN\s+\(\?[^\)]*\)/.freeze
+      PSQL_AFTER_FROM = /(?:FROM\s+).*?(?:WHERE|\z)/im.freeze # Should be everything between a FROM and a WHERE
+      PSQL_AFTER_JOIN = /(?:JOIN\s+).*?\z/im.freeze
+      PSQL_AFTER_WHERE = /(?:WHERE\s+).*?(?:SELECT|\z)/im.freeze
+      PSQL_AFTER_SET = /(?:SET\s+).*?(?:WHERE|\z)/im.freeze
+
+      MYSQL_VAR_INTERPOLATION = %r|\[\[.*\]\]\s*$|.freeze
+      MYSQL_REMOVE_INTEGERS = /(?<!LIMIT )\b\d+\b/.freeze
+      MYSQL_REMOVE_SINGLE_QUOTE_STRINGS = %r{'(?:\\'|[^']|'')*'}.freeze
+      MYSQL_REMOVE_DOUBLE_QUOTE_STRINGS = %r{"(?:\\"|[^"]|"")*"}.freeze
+      MYSQL_IN_CLAUSE = /IN\s+\(\?[^\)]*\)/.freeze
+
+      SQLITE_VAR_INTERPOLATION = %r|\[\[.*\]\]\s*$|.freeze
+      SQLITE_REMOVE_STRINGS = /'(?:[^']|'')*'/.freeze
+      SQLITE_REMOVE_INTEGERS = /(?<!LIMIT )\b\d+\b/.freeze
+
+      # => "EXEC sp_executesql N'SELECT  [users].* FROM [users] WHERE (age > 50)  ORDER BY [users].[id] ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY', N'@0 int', @0 = 10"
+      SQLSERVER_EXECUTESQL = /EXEC sp_executesql N'(.*?)'.*/
+      SQLSERVER_REMOVE_INTEGERS = /(?<!LIMIT )\b(?<!@)\d+\b/.freeze
+      SQLSERVER_IN_CLAUSE = /IN\s+\(\?[^\)]*\)/.freeze
 
       attr_accessor :database_engine
 
@@ -50,7 +74,9 @@ module ScoutApm
       def to_s_postgres
         sql.gsub!(PSQL_PLACEHOLDER, '?')
         sql.gsub!(PSQL_VAR_INTERPOLATION, '')
+        # sql.gsub!(PSQL_REMOVE_STRINGS, '?')
         sql.gsub!(PSQL_AFTER_WHERE) {|c| c.gsub(PSQL_REMOVE_STRINGS, '?')}
+        sql.gsub!(PSQL_AFTER_JOIN) {|c| c.gsub(PSQL_REMOVE_STRINGS, '?')}
         sql.gsub!(PSQL_AFTER_SET) {|c| c.gsub(PSQL_REMOVE_STRINGS, '?')}
         sql.gsub!(PSQL_REMOVE_INTEGERS, '?')
         sql.gsub!(PSQL_IN_CLAUSE, 'IN (?)')

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "4.0.4"
+  VERSION = "5.0.0"
 end

data/lib/scout_apm.rb

@@ -42,6 +42,7 @@ require 'scout_apm/layer_converters/job_converter'
 require 'scout_apm/layer_converters/slow_job_converter'
 require 'scout_apm/layer_converters/metric_converter'
 require 'scout_apm/layer_converters/database_converter'
+require 'scout_apm/layer_converters/external_service_converter'
 require 'scout_apm/layer_converters/slow_request_converter'
 require 'scout_apm/layer_converters/request_queue_time_converter'
 require 'scout_apm/layer_converters/allocation_metric_converter'
@@ -130,6 +131,7 @@ require 'scout_apm/bucket_name_splitter'
 require 'scout_apm/stack_item'
 require 'scout_apm/metric_set'
 require 'scout_apm/db_query_metric_set'
+require 'scout_apm/external_service_metric_set'
 require 'scout_apm/store'
 require 'scout_apm/fake_store'
 require 'scout_apm/tracer'
@@ -142,6 +144,7 @@ require 'scout_apm/synchronous_recorder'
 require 'scout_apm/metric_meta'
 require 'scout_apm/metric_stats'
 require 'scout_apm/db_query_metric_stats'
+require 'scout_apm/external_service_metric_stats'
 require 'scout_apm/slow_transaction'
 require 'scout_apm/slow_job_record'
 require 'scout_apm/detailed_trace'
@@ -167,6 +170,7 @@ require 'scout_apm/serializers/slow_jobs_serializer_to_json'
 require 'scout_apm/serializers/metrics_to_json_serializer'
 require 'scout_apm/serializers/histograms_serializer_to_json'
 require 'scout_apm/serializers/db_query_serializer_to_json'
+require 'scout_apm/serializers/external_service_serializer_to_json'
 require 'scout_apm/serializers/directive_serializer'
 require 'scout_apm/serializers/app_server_load_serializer'
 
@@ -193,6 +197,7 @@ require 'scout_apm/tasks/support'
 require 'scout_apm/extensions/config'
 require 'scout_apm/extensions/transaction_callback_payload'
 
+require 'scout_apm/error'
 require 'scout_apm/error_service'
 require 'scout_apm/error_service/middleware'
 require 'scout_apm/error_service/notifier'

data/scout_apm.gemspec

@@ -12,8 +12,6 @@ Gem::Specification.new do |s|
   s.description = "Monitors Ruby apps and reports detailed metrics on performance to Scout."
   s.license     = "Proprietary (See LICENSE.md)"
 
-  s.rubyforge_project = "scout_apm"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/test/unit/auto_instrument/anonymous_block_value.rb

@@ -0,0 +1,7 @@
+class TestController < ApplicationController
+  def index
+    quests = policy_scope(Quest.open)
+    quests.each { _1.current_user = current_user }
+    respond_with_proto quests
+  end
+end

data/test/unit/auto_instrument/hanging_method.rb

@@ -0,0 +1,6 @@
+class TestController < ApplicationController
+end
+
+def hanging_method
+  Test.first
+end

data/test/unit/auto_instrument_test.rb

@@ -51,4 +51,12 @@ class AutoInstrumentTest < Minitest::Test
     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/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/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
+    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/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