scout_apm 5.7.1 → 6.0.0

data/lib/scout_apm/instruments/httpx.rb

@@ -0,0 +1,119 @@
+module ScoutApm
+  module Instruments
+    class HTTPX
+      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?(::HTTPX) && defined?(::HTTPX::Session)
+          @installed = true
+
+          logger.info "Instrumenting HTTPX"
+
+          ::HTTPX::Session.send(:prepend, HTTPXInstrumentationPrepend)
+        end
+      end
+
+      module HTTPXInstrumentationPrepend
+        def request(*args, **params)
+          verb, desc = determine_verb_and_desc(*args, **params)
+
+          layer = ScoutApm::Layer.new("HTTP", verb)
+          layer.desc = desc
+
+          req = ScoutApm::RequestManager.lookup
+          req.start_layer(layer)
+
+          begin
+            super(*args, **params)
+          ensure
+            req.stop_layer
+          end
+        end
+
+        private
+
+        # See the following for various argument patterns:
+        # https://gitlab.com/os85/httpx/-/blob/v1.6.3/lib/httpx/session.rb?ref_type=tags#L87
+        def determine_verb_and_desc(*args, **params)
+          # Pattern 1: session.request(req1) or session.request(req1, req2, ...)
+          if args.first.is_a?(::HTTPX::Request)
+            if args.length > 1
+              return args.first.verb.to_s.upcase, "#{args.length} requests"
+            else
+              return args.first.verb.to_s.upcase, scout_url_desc(args.first.uri)
+            end
+          end
+
+          # Pattern 2: session.request("GET", "https://server.org/a")
+          # Pattern 3: session.request("GET", ["https://server.org/a", "https://server.org/b"])
+          # Pattern 4: session.request("POST", ["https://server.org/a"], form: { ... })
+          # Pattern 5: session.request("GET", ["https://..."], headers: { ... })
+          if args.first.is_a?(String) || args.first.is_a?(Symbol)
+            verb = args.first.to_s.upcase
+
+            if args[1].is_a?(String)
+              return verb, scout_url_desc(args[1])
+            elsif args[1].is_a?(Array)
+              return verb, scout_url_desc(args[1][0]) unless args[1].length > 1
+              return verb, "#{args[1].length} requests"
+            else
+              return verb, ""
+            end
+          end
+
+          # Pattern 6: session.request(["GET", "https://..."], ["GET", "https://..."])
+          # Pattern 7: session.request(["POST", "https://...", form: {...}], ["GET", "https://..."])
+          if args.first.is_a?(Array)
+            if args.length > 1
+              verb = args.first[0].to_s.upcase rescue "REQUEST"
+              return verb, "#{args.length} requests"
+            elsif args.first.length >= 2
+              verb = args.first[0].to_s.upcase rescue "REQUEST"
+              url = args.first[1]
+              return verb, scout_url_desc(url)
+            end
+          end
+
+          return "REQUEST", ""
+        end
+
+        def scout_url_desc(uri)
+          max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
+          uri_str = uri.to_s
+
+          # URI object
+          if uri.respond_to?(:host) && uri.respond_to?(:path)
+            path = uri.path.to_s
+            path = "/" if path.empty?
+            result = "#{uri.host}#{path.split('?').first}"
+          # String URL
+          elsif uri_str =~ %r{^https?://([^/]+)(/[^?]*)?}
+            host = $1
+            path = $2 || "/"
+            result = "#{host}#{path}"
+          else
+            # Fallback
+            result = uri_str.split('?').first
+          end
+
+          result[0..(max_length - 1)]
+        rescue => e
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/opensearch.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: false
+
+module ScoutApm
+  module Instruments
+    class OpenSearch
+      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?(::OpenSearch) &&
+            defined?(::OpenSearch::Transport) &&
+            defined?(::OpenSearch::Transport::Client)
+
+          @installed = true
+
+          logger.info "Instrumenting OpenSearch. Prepend: #{prepend}"
+
+          if prepend
+            ::OpenSearch::Transport::Client.send(:include, ScoutApm::Tracer)
+            ::OpenSearch::Transport::Client.send(:prepend, OpenSearchTransportClientInstrumentationPrepend)
+          else
+            ::OpenSearch::Transport::Client.class_eval do
+              include ScoutApm::Tracer
+
+              def perform_request_with_scout_instruments(*args, &block)
+                name = _sanitize_name(args[1])
+
+                self.class.instrument("OpenSearch", name, :ignore_children => true) do
+                  perform_request_without_scout_instruments(*args, &block)
+                end
+              end
+
+              alias_method :perform_request_without_scout_instruments, :perform_request
+              alias_method :perform_request, :perform_request_with_scout_instruments
+
+              def _sanitize_name(path)
+                name = path.split("/").last.gsub(/^_/, '')
+                allowed_names = ["bench",
+                                "bulk",
+                                "count",
+                                "exists",
+                                "explain",
+                                "field_stats",
+                                "health",
+                                "mget",
+                                "mlt",
+                                "mpercolate",
+                                "msearch",
+                                "mtermvectors",
+                                "percolate",
+                                "query",
+                                "scroll",
+                                "search_shards",
+                                "source",
+                                "suggest",
+                                "template",
+                                "termvectors",
+                                "update",
+                                "search", ]
+
+                if allowed_names.include?(name)
+                  name
+                else
+                  "Unknown"
+                end
+              rescue
+                "Unknown"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module OpenSearchTransportClientInstrumentationPrepend
+      def perform_request(*args, &block)
+        name = _sanitize_name(args[1])
+
+        self.class.instrument("OpenSearch", name, :ignore_children => true) do
+          super(*args, &block)
+        end
+      end
+
+      def _sanitize_name(path)
+        name = path.split("/").last.gsub(/^_/, '')
+        allowed_names = ["bench",
+                        "bulk",
+                        "count",
+                        "exists",
+                        "explain",
+                        "field_stats",
+                        "health",
+                        "mget",
+                        "mlt",
+                        "mpercolate",
+                        "msearch",
+                        "mtermvectors",
+                        "percolate",
+                        "query",
+                        "scroll",
+                        "search_shards",
+                        "source",
+                        "suggest",
+                        "template",
+                        "termvectors",
+                        "update",
+                        "search", ]
+
+        if allowed_names.include?(name)
+          name
+        else
+          "Unknown"
+        end
+      rescue
+        "Unknown"
+      end
+    end
+  end
+end

data/lib/scout_apm/limited_layer.rb

@@ -21,10 +21,13 @@ module ScoutApm
       @total_layers += 1
 
       @total_call_time += layer.total_call_time
-      @total_exclusive_time += layer.total_exclusive_time
+      # For limited layers, exclusive time should equal total time since limited layers
+      # report no children. As such, we need to consider all absorbed time as exclusive.
+      @total_exclusive_time += layer.total_call_time
 
       @total_allocations += layer.total_allocations
-      @total_exclusive_allocations += layer.total_exclusive_allocations
+      # Same logic applies to allocations
+      @total_exclusive_allocations += layer.total_allocations
     end
 
     def total_call_time

data/lib/scout_apm/logger.rb

@@ -145,7 +145,7 @@ module ScoutApm
       def call(severity, time, progname, msg)
         # since STDOUT isn't exclusive like the scout_apm.log file, apply a prefix.
         # XXX: Pass in context to the formatter
-        "[#{Utils::Time.to_s(time)} #{ScoutApm::Agent.instance.context.environment.hostname} (#{$$})] #{severity} : #{msg}\n"
+        "[#{time.strftime("%m/%d/%y %H:%M:%S %z")} #{ScoutApm::Agent.instance.context.environment.hostname} (#{$$})] #{severity} : #{msg}\n"
       end
     end
 

data/lib/scout_apm/sampling.rb

@@ -8,7 +8,8 @@ module ScoutApm
       # jobs matched explicitly by name
 
       # for now still support old config key ('ignore') for backwards compatibility
-      @ignore_endpoints = config.value_present?('ignore') ? config.value('ignore') : config.value('ignore_endpoints')
+      raw_ignore = config.value_present?('ignore') ? config.value('ignore') : config.value('ignore_endpoints')
+      @ignore_endpoints = IgnoredUris.new(raw_ignore) unless raw_ignore.blank?
       @sample_endpoints = individual_sample_to_hash(config.value('sample_endpoints'))
       @endpoint_sample_rate = config.value('endpoint_sample_rate')
 
@@ -34,20 +35,20 @@ module ScoutApm
       if transaction.job?
         job_name = transaction.layer_finder.job.name
         rate = job_sample_rate(job_name)
-        return sample?(rate) unless rate.nil?
+        return downsample?(rate) unless rate.nil?
         return true if ignore_job?(job_name)
-        return sample?(@job_sample_rate) unless @job_sample_rate.nil?
+        return downsample?(@job_sample_rate) unless @job_sample_rate.nil?
       elsif transaction.web?
         uri = transaction.annotations[:uri]
         rate = web_sample_rate(uri)
-        return sample?(rate) unless rate.nil?
+        return downsample?(rate) unless rate.nil?
         return true if ignore_uri?(uri)
-        return sample?(@endpoint_sample_rate) unless @endpoint_sample_rate.nil?
+        return downsample?(@endpoint_sample_rate) unless @endpoint_sample_rate.nil?
       end
 
       # global sample check
       if @global_sample_rate
-        return sample?(@global_sample_rate)
+        return downsample?(@global_sample_rate)
       end
 
       false # don't drop the request
@@ -59,17 +60,14 @@ module ScoutApm
       sample_hash = {}
       sampling_config.each do |sample|
         path, _, rate = sample.rpartition(':')
-        sample_hash[path] = rate.to_i
+        sample_hash[path] = coerce_to_rate(rate)
       end
       sample_hash
     end
 
     def ignore_uri?(uri)
       return false if @ignore_endpoints.blank?
-      @ignore_endpoints.each do |prefix|
-        return true if uri.start_with?(prefix)
-      end
-      false
+      @ignore_endpoints.ignore?(uri)
     end
 
     def web_sample_rate(uri)
@@ -90,8 +88,9 @@ module ScoutApm
       @sample_jobs.fetch(job_name, nil)
     end
 
-    def sample?(rate)
-      rand * 100 > rate
+    def downsample?(rate)
+      # Should we drop this request based on the sample rate?
+      rand > rate
     end
 
     private
@@ -100,5 +99,18 @@ module ScoutApm
       ScoutApm::Agent.instance.logger
     end
 
+    def coerce_to_rate(val)
+      # Analogous to Config::SampleRateCoercion
+      v = val.to_f
+      # Anything above 1 is assumed a percentage for backwards compat, so convert to a decimal
+      if v > 1
+        v = v / 100
+      end
+      if v < 0 || v > 1
+        logger.warn("Sample rates must be between 0 and 1. You passed in #{val.inspect}, which we interpreted as #{v}. Clamping.")
+        v = v.clamp(0, 1)
+      end
+      v
+    end
   end
 end

data/lib/scout_apm/server_integrations/puma.rb

@@ -53,11 +53,28 @@ module ScoutApm
       #
       def install
         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
-        end]
 
+        hook =
+          if Gem::Version.new(::Puma::Const::PUMA_VERSION) < Gem::Version.new("7.0.0")
+            # Puma < 7 uses a raw block
+            Proc.new do
+              logger.info "Installing Puma worker loop."
+              ScoutApm::Agent.instance.start_background_worker
+            end
+          else
+            # Puma >= 7 uses the structured hook format:
+            # https://github.com/puma/puma/commit/b16790f7a3c1bfc1847225a58897c9fbd19981f8
+            {
+              block: Proc.new {
+                logger.info "Installing Puma worker loop."
+                ScoutApm::Agent.instance.start_background_worker
+              },
+              id: nil,
+              cluster_only: false
+            }
+          end
+        
+        new = Array.new(old) + [hook]
         ::Puma.cli_config.options[:before_worker_boot] = new
       rescue
         logger.warn "Unable to install Puma worker loop: #{$!.message}"

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "5.7.1"
+  VERSION = "6.0.0"
 end

data/lib/scout_apm.rb

@@ -84,6 +84,7 @@ require 'scout_apm/histogram'
 require 'scout_apm/instruments/net_http'
 require 'scout_apm/instruments/http_client'
 require 'scout_apm/instruments/http'
+require 'scout_apm/instruments/httpx'
 require 'scout_apm/instruments/typhoeus'
 require 'scout_apm/instruments/moped'
 require 'scout_apm/instruments/mongoid'
@@ -92,6 +93,7 @@ require 'scout_apm/instruments/redis'
 require 'scout_apm/instruments/redis5'
 require 'scout_apm/instruments/influxdb'
 require 'scout_apm/instruments/elasticsearch'
+require 'scout_apm/instruments/opensearch'
 require 'scout_apm/instruments/active_record'
 require 'scout_apm/instruments/action_controller_rails_2'
 require 'scout_apm/instruments/action_controller_rails_3_rails4'
@@ -118,7 +120,6 @@ require 'scout_apm/utils/installed_gems'
 require 'scout_apm/utils/klass_helper'
 require 'scout_apm/utils/scm'
 require 'scout_apm/utils/sql_sanitizer'
-require 'scout_apm/utils/time'
 require 'scout_apm/utils/unique_id'
 require 'scout_apm/utils/numbers'
 require 'scout_apm/utils/gzip_helper'
@@ -226,11 +227,15 @@ if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR
         # Attempt to start right away, this will work best for preloading apps, Unicorn & Puma & similar
         ScoutApm::Agent.instance.install
 
-        if ScoutApm::Agent.instance.context.config.value("auto_instruments")
-          if defined?(Parser::TreeRewriter)
+        if ScoutApm::Agent.instance.context.config.value("auto_instruments") &&
+            ScoutApm::Agent.instance.should_load_instruments?
+          require 'scout_apm/auto_instrument/requirements'
+          if defined?(Prism) || defined?(Parser::TreeRewriter)
             ScoutApm::Agent.instance.context.logger.debug("AutoInstruments is enabled.")
             require 'scout_apm/auto_instrument'
-          else # AutoInstruments is turned on, but we don't he the prerequisites to use it
+          else 
+            # AutoInstruments is turned on, but we don't have the prerequisites to use it
+            # Prism should be available for Ruby >= 3.3.0
             ScoutApm::Agent.instance.context.logger.debug("AutoInstruments is enabled, but Parser::TreeRewriter is missing. Update 'parser' gem to >= 2.5.0.")
           end
         else