scout_apm 5.1.1 → 5.3.5

data/lib/scout_apm/instruments/mongoid.rb

@@ -16,7 +16,7 @@ module ScoutApm
         @installed
       end
 
-      def install
+      def install(prepend:)
         @installed = true
 
         # Mongoid versions that use Moped should instrument Moped.

data/lib/scout_apm/instruments/moped.rb

@@ -16,32 +16,37 @@ module ScoutApm
         @installed
       end
 
-      def install
+      def install(prepend:)
         if defined?(::Moped)
           @installed = true
 
-          logger.info "Instrumenting Moped"
+          logger.info "Instrumenting Moped. Prepend: #{prepend}"
 
-          ::Moped::Node.class_eval do
-            include ScoutApm::Tracer
+          if prepend
+            ::Moped::Node.send(:include, ScoutApm::Tracer)
+            ::Moped::Node.send(:prepend, MopedInstrumentationPrepend)
+          else
+            ::Moped::Node.class_eval do
+              include ScoutApm::Tracer
 
-            def process_with_scout_instruments(operation, &callback)
-              if operation.respond_to?(:collection)
-                collection = operation.collection
-                name = "Process/#{collection}/#{operation.class.to_s.split('::').last}"
-                self.class.instrument("MongoDB", name, :annotate_layer => { :query => scout_sanitize_log(operation.log_inspect) }) do
-                  process_without_scout_instruments(operation, &callback)
+              def process_with_scout_instruments(operation, &callback)
+                if operation.respond_to?(:collection)
+                  collection = operation.collection
+                  name = "Process/#{collection}/#{operation.class.to_s.split('::').last}"
+                  self.class.instrument("MongoDB", name, :annotate_layer => { :query => scout_sanitize_log(operation.log_inspect) }) do
+                    process_without_scout_instruments(operation, &callback)
+                  end
                 end
               end
-            end
-            alias_method :process_without_scout_instruments, :process
-            alias_method :process, :process_with_scout_instruments
-
-            # replaces values w/ ?
-            def scout_sanitize_log(log)
-              return nil if log.length > 1000 # safeguard - don't sanitize large SQL statements
-              log.gsub(/(=>")((?:[^"]|"")*)"/) do
-                $1 + '?' + '"'
+              alias_method :process_without_scout_instruments, :process
+              alias_method :process, :process_with_scout_instruments
+
+              # replaces values w/ ?
+              def scout_sanitize_log(log)
+                return nil if log.length > 1000 # safeguard - don't sanitize large SQL statements
+                log.gsub(/(=>")((?:[^"]|"")*)"/) do
+                  $1 + '?' + '"'
+                end
               end
             end
           end
@@ -49,6 +54,26 @@ module ScoutApm
       end
 
     end
+
+    module MopedInstrumentationPrepend
+      def process(operation, &callback)
+        if operation.respond_to?(:collection)
+          collection = operation.collection
+          name = "Process/#{collection}/#{operation.class.to_s.split('::').last}"
+          self.class.instrument("MongoDB", name, :annotate_layer => { :query => scout_sanitize_log(operation.log_inspect) }) do
+            super(operation, &callback)
+          end
+        end
+      end
+
+      # replaces values w/ ?
+      def scout_sanitize_log(log)
+        return nil if log.length > 1000 # safeguard - don't sanitize large SQL statements
+        log.gsub(/(=>")((?:[^"]|"")*)"/) do
+          $1 + '?' + '"'
+        end
+      end
+    end
   end
 end
 

data/lib/scout_apm/instruments/net_http.rb

@@ -16,41 +16,69 @@ module ScoutApm
         @installed
       end
 
-      def install
+      def install(prepend:)
         if defined?(::Net) && defined?(::Net::HTTP)
           @installed = true
 
-          logger.info "Instrumenting Net::HTTP"
+          logger.info "Instrumenting Net::HTTP. Prepend: #{prepend}"
 
-          ::Net::HTTP.class_eval do
-            include ScoutApm::Tracer
+          if prepend
+            ::Net::HTTP.send(:include, ScoutApm::Tracer)
+            ::Net::HTTP.send(:prepend, NetHttpInstrumentationPrepend)
+          else
+            ::Net::HTTP.class_eval do
+              include ScoutApm::Tracer
 
-            def request_with_scout_instruments(*args, &block)
-              self.class.instrument("HTTP", "request", :ignore_children => true, :desc => request_scout_description(args.first)) do
-                request_without_scout_instruments(*args, &block)
+              def request_with_scout_instruments(*args, &block)
+                self.class.instrument("HTTP", "request", :ignore_children => true, :desc => request_scout_description(args.first)) do
+                  request_without_scout_instruments(*args, &block)
+                end
               end
-            end
 
-            def request_scout_description(req)
-              path = req.path
-              path = path.path if path.respond_to?(:path)
+              def request_scout_description(req)
+                path = req.path
+                path = path.path if path.respond_to?(:path)
+
+                # Protect against a nil address value
+                if @address.nil?
+                  return "No Address Found"
+                end
 
-              # Protect against a nil address value
-              if @address.nil?
-                return "No Address Found"
+                max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
+                (@address + path.split('?').first)[0..(max_length - 1)]
+              rescue
+                ""
               end
 
-              max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
-              (@address + path.split('?').first)[0..(max_length - 1)]
-            rescue
-              ""
+              alias request_without_scout_instruments request
+              alias request request_with_scout_instruments
             end
-
-            alias request_without_scout_instruments request
-            alias request request_with_scout_instruments
           end
         end
       end
     end
+
+    module NetHttpInstrumentationPrepend
+      def request(request, *args, &block)
+        self.class.instrument("HTTP", "request", :ignore_children => true, :desc => request_scout_description(request)) do
+          super(request, *args, &block)
+        end
+      end
+
+      def request_scout_description(req)
+        path = req.path
+        path = path.path if path.respond_to?(:path)
+
+        # Protect against a nil address value
+        if @address.nil?
+          return "No Address Found"
+        end
+
+        max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
+        (@address + path.split('?').first)[0..(max_length - 1)]
+      rescue
+        ""
+      end
+    end
   end
 end

data/lib/scout_apm/instruments/rails_router.rb

@@ -16,7 +16,7 @@ module ScoutApm
         @installed
       end
 
-      def install
+      def install(prepend:)
         if defined?(ActionDispatch) && defined?(ActionDispatch::Routing) && defined?(ActionDispatch::Routing::RouteSet)
           @installed = true
 

data/lib/scout_apm/instruments/redis.rb

@@ -16,28 +16,43 @@ module ScoutApm
         @installed
       end
 
-      def install
-        if defined?(::Redis) && defined?(::Redis::Client)
+      def install(prepend:)
+        if defined?(::Redis) && defined?(::Redis::Client) && ::Redis::Client.instance_methods(false).include?(:call)
           @installed = true
 
-          logger.info "Instrumenting Redis"
+          logger.info "Instrumenting Redis. Prepend: #{prepend}"
 
-          ::Redis::Client.class_eval do
-            include ScoutApm::Tracer
+          if prepend
+            ::Redis::Client.send(:include, ScoutApm::Tracer)
+            ::Redis::Client.send(:prepend, RedisClientInstrumentationPrepend)
+          else
+            ::Redis::Client.class_eval do
+              include ScoutApm::Tracer
 
-            def call_with_scout_instruments(*args, &block)
-              command = args.first.first rescue "Unknown"
+              def call_with_scout_instruments(*args, &block)
+                command = args.first.first rescue "Unknown"
 
-              self.class.instrument("Redis", command) do
-                call_without_scout_instruments(*args, &block)
+                self.class.instrument("Redis", command) do
+                  call_without_scout_instruments(*args, &block)
+                end
               end
-            end
 
-            alias_method :call_without_scout_instruments, :call
-            alias_method :call, :call_with_scout_instruments
+              alias_method :call_without_scout_instruments, :call
+              alias_method :call, :call_with_scout_instruments
+            end
           end
         end
       end
     end
+
+    module RedisClientInstrumentationPrepend
+      def call(*args, &block)
+        command = args.first.first rescue "Unknown"
+
+        self.class.instrument("Redis", command) do
+          super(*args, &block)
+        end
+      end
+    end
   end
 end

data/lib/scout_apm/instruments/redis5.rb

@@ -0,0 +1,59 @@
+module ScoutApm
+    module Instruments
+      class Redis5
+        attr_reader :context
+  
+        def initialize(context)
+          @context = context
+          @installed = false
+        end
+  
+        def logger
+          context.logger
+        end
+  
+        def installed?
+          @installed
+        end
+  
+        def install(prepend:)
+          if defined?(::Redis) && defined?(::Redis::Client) && ::Redis::Client.instance_methods(false).include?(:call_v)
+            @installed = true
+  
+            logger.info "Instrumenting Redis5. Prepend: #{prepend}"
+  
+            if prepend
+              ::Redis::Client.send(:include, ScoutApm::Tracer)
+              ::Redis::Client.send(:prepend, Redis5ClientInstrumentationPrepend)
+            else
+              ::Redis::Client.class_eval do
+                include ScoutApm::Tracer
+  
+                def call_with_scout_instruments(args, &block)
+                  command = args.first rescue "Unknown"
+  
+                  self.class.instrument("Redis", command) do
+                    call_without_scout_instruments(args, &block)
+                  end
+                end
+  
+                alias_method :call_without_scout_instruments, :call_v
+                alias_method :call_v, :call_with_scout_instruments
+              end
+            end
+          end
+        end
+      end
+  
+      module Redis5ClientInstrumentationPrepend
+        def call(args, &block)
+          command = args.first rescue "Unknown"
+  
+          self.class.instrument("Redis", command) do
+            super(args, &block)
+          end
+        end
+      end
+    end
+  end
+  

data/lib/scout_apm/instruments/sinatra.rb

@@ -15,7 +15,7 @@ module ScoutApm
         @installed
       end
 
-      def install
+      def install(prepend:)
         if defined?(::Sinatra) && defined?(::Sinatra::Base) && ::Sinatra::Base.private_method_defined?(:dispatch!)
           @installed = true
 

data/lib/scout_apm/instruments/typhoeus.rb

@@ -16,7 +16,7 @@ module ScoutApm
         @installed
       end
 
-      def install
+      def install(prepend:)
         if defined?(::Typhoeus)
           @installed = true
 

data/lib/scout_apm/layer_converters/external_service_converter.rb

@@ -53,7 +53,7 @@ module ScoutApm
       rescue
         # Do nothing
       ensure
-        domain = DEFAULT_DOMAIN if domain.to_s.blank?
+        domain = DEFAULT_DOMAIN if (domain.nil? || domain.empty?)
         domain
       end
 

data/lib/scout_apm/server_integrations/puma.rb

@@ -23,8 +23,36 @@ module ScoutApm
         defined?(::Puma) && (File.basename($0) =~ /\Apuma/)
       end
 
+      # Puma::UserFileDefaultOptions exposes `options` based on three underlying
+      # hashes: user_options, file_options, and default_options. While getting an `options`
+      # key consults all three underlying hashes, setting an `options` key only sets the
+      # user_options hash:
+      #
+      #    def [](key)
+      #      fetch(key)
+      #    end
+      #
+      #    def []=(key, value)
+      #      user_options[key] = value
+      #    end
+      #
+      #    def fetch(key, default_value = nil)
+      #      return user_options[key]    if user_options.key?(key)
+      #      return file_options[key]    if file_options.key?(key)
+      #      return default_options[key] if default_options.key?(key)
+      #
+      #      default_value
+      #    end
+      #
+      # Because of this, we can't read options[:before_worker_boot], modify, and then re-set
+      # options[:before_worker_boot], since doing so could cause duplication if `before_worker_boot`
+      # exists on the other two underlying hashes (file_options, default_options).
+      #
+      # To get around this, we explicitly read from `user_options` only, and still set using `options[]=`,
+      # which Puma allows for setting `user_options`.
+      #
       def install
-        old = ::Puma.cli_config.options[:before_worker_boot] || []
+        old = ::Puma.cli_config.options.user_options[:before_worker_boot] || []
         new = Array(old) + [Proc.new do
           logger.info "Installing Puma worker loop."
           ScoutApm::Agent.instance.start_background_worker

data/lib/scout_apm/slow_request_policy.rb

@@ -14,7 +14,7 @@ module ScoutApm
 
     def add_default_policies
       add(SlowPolicy::SpeedPolicy.new(context))
-      add(SlowPolicy::PercentilePolicy.new(context))
+      add(SlowPolicy::PercentPolicy.new(context))
       add(SlowPolicy::AgePolicy.new(context))
       add(SlowPolicy::PercentilePolicy.new(context))
     end

data/lib/scout_apm/store.rb

@@ -217,6 +217,7 @@ module ScoutApm
 
     def initialize(timestamp, context)
       @timestamp = timestamp
+      @context = context
 
       @request_traces = ScoredItemSet.new(context.config.value('max_traces'))
       @job_traces = ScoredItemSet.new(context.config.value('max_traces'))
@@ -230,6 +231,11 @@ module ScoutApm
       @jobs = Hash.new
     end
 
+    def logger
+      @context.logger
+    end
+    private :logger
+
     # Merges another StoreReportingPeriod into this one
     def merge(other)
       self.

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "5.1.1"
+  VERSION = "5.3.5"
 end

data/lib/scout_apm.rb

@@ -87,6 +87,7 @@ require 'scout_apm/instruments/moped'
 require 'scout_apm/instruments/mongoid'
 require 'scout_apm/instruments/memcached'
 require 'scout_apm/instruments/redis'
+require 'scout_apm/instruments/redis5'
 require 'scout_apm/instruments/influxdb'
 require 'scout_apm/instruments/elasticsearch'
 require 'scout_apm/instruments/active_record'

data/test/test_helper.rb

@@ -65,6 +65,32 @@ class FakeEnvironment
   end
 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
+
 # Helpers available to all tests
 class Minitest::Test
   def setup

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

@@ -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/instruments/active_record_test.rb

@@ -24,12 +24,42 @@ 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
 
     instrument = ScoutApm::Instruments::ActiveRecord.new(agent_context)
-    instrument.install
+    instrument.install(prepend: false)
 
     ScoutApm::Tracer.instrument("Controller", "foo/bar") do
       user = User.create

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