scout_apm 2.5.1 → 5.3.2

data/lib/scout_apm/error_service/sidekiq.rb

@@ -0,0 +1,80 @@
+module ScoutApm
+  module ErrorService
+    class Sidekiq
+      def initialize
+        @context = ScoutApm::Agent.instance.context
+      end
+
+      def install
+        return false unless defined?(::Sidekiq)
+
+        if ::Sidekiq::VERSION < "3"
+          install_sidekiq_with_middleware
+        else
+          install_sidekiq_with_error_handler
+        end
+
+        true
+      end
+
+      def install_sidekiq_with_middleware
+        # old behavior
+        ::Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add ScoutApm::ErrorService::Sidekiq::SidekiqExceptionMiddleware
+          end
+        end
+      end
+
+      def install_sidekiq_with_error_handler
+        ::Sidekiq.configure_server do |config|
+          config.error_handlers << proc { |exception, job_info|
+            context = ScoutApm::Agent.instance.context
+
+            # Bail out early, and reraise if the error is not interesting.
+            if context.ignored_exceptions.ignored?(exception)
+              raise
+            end
+
+            job_class =
+              begin
+                job_class = job_info[:job]["class"]
+                job_class = job_info[:job]["args"][0]["job_class"] if job_class == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+                job_class
+              rescue
+                "UnknownJob"
+              end
+
+            # Capture the error for further processing and shipping
+            context.error_buffer.capture(exception, job_info.merge(:custom_controller => job_class))
+          }
+        end
+      end
+
+      class SidekiqExceptionMiddleware
+        def call(worker, msg, queue)
+          yield
+        rescue => exception
+          context = ScoutApm::Agent.instance.context
+
+          # Bail out early, and reraise if the error is not interesting.
+          if context.ignored_exceptions.ignored?(exception)
+            raise
+          end
+
+          # Capture the error for further processing and shipping
+          context.error_buffer.capture(
+            exception,
+            {
+              :custom_params => msg,
+              :custom_controller => msg["class"]
+            }
+          )
+
+          # Finally, reraise
+          raise exception
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service.rb

@@ -0,0 +1,34 @@
+require "net/http"
+require "net/https"
+require "uri"
+
+module ScoutApm
+  module ErrorService
+    API_VERSION = "1"
+
+    HEADERS = {
+      "Content-type" => "application/json",
+      "Accept" => "application/json"
+    }
+
+    # Public API to force a given exception to be captured.
+    # Still obeys the ignore list
+    # Used internally by SidekiqException
+    def self.capture(exception, params = {})
+      return if disabled?
+
+      context = ScoutApm::Agent.instance.context
+      return if context.ignored_exceptions.ignore?(exception)
+
+      context.errors_buffer.capture(exception, env)
+    end
+
+    def self.enabled?
+      ScoutApm::Agent.instance.context.config.value("errors_enabled")
+    end
+
+    def self.disabled?
+      !enabled?
+    end
+  end
+end

data/lib/scout_apm/exceptions.rb

@@ -0,0 +1,12 @@
+module ScoutApm
+  module AllExceptionsExceptOnesWeMustNotRescue
+    # Borrowed from https://github.com/rspec/rspec-support/blob/v3.8.0/lib/rspec/support.rb#L132-L140
+    # These exceptions are dangerous to rescue as rescuing them
+    # would interfere with things we should not interfere with.
+    AVOID_RESCUING = [NoMemoryError, SignalException, Interrupt, SystemExit]
+
+    def self.===(exception)
+      AVOID_RESCUING.none? { |ar| ar === exception }
+    end
+  end
+end

data/lib/scout_apm/extensions/transaction_callback_payload.rb

@@ -26,7 +26,7 @@ module ScoutApm
       # The time in queue of the transaction in ms. If not present, +nil+ is returned as this is unknown.
       def queue_time_ms
         # Controller logic
-        if converter_results[:queue_time] && converter_results[:queue].any?
+        if converter_results[:queue_time] && converter_results[:queue_time].any?
           converter_results[:queue_time].values.first.total_call_time*1000 # ms
         # Job logic
         elsif converter_results[:job]

data/lib/scout_apm/external_service_metric_set.rb

@@ -0,0 +1,97 @@
+# Note, this class must be Marshal Dumpable
+module ScoutApm
+  class ExternalServiceMetricSet
+    include Enumerable
+
+    attr_reader :metrics # the raw metrics. You probably want #metrics_to_report
+
+    def marshal_dump
+      [ @metrics ]
+    end
+
+    def marshal_load(array)
+      @metrics = array.first
+      @context = ScoutApm::Agent.instance.context
+    end
+
+    def initialize(context)
+      @context = context
+
+      # A hash of ExternalServiceMetricStats values, keyed by ExternalServiceMetricStats.key
+      @metrics = Hash.new
+    end
+
+    # Need to look this up again if we end up as nil. Which I guess can happen
+    # after a Marshal load?
+    def context
+      @context ||= ScoutApm::Agent.instance.context
+    end
+
+    def each
+      metrics.each do |_key, external_service_metric_stat|
+        yield external_service_metric_stat
+      end
+    end
+
+    # Looks up a ExternalServiceMetricStats instance in the +@metrics+ hash. Sets the value to +other+ if no key
+    # Returns a ExternalServiceMetricStats instance
+    def lookup(other)
+      metrics[other.key] ||= other
+    end
+
+    # Take another set, and merge it with this one
+    def combine!(other)
+      other.each do |metric|
+        self << metric
+      end
+      self
+    end
+
+    # Add a single ExternalServiceMetricStats object to this set.
+    #
+    # Looks up an existing one under this key and merges, or just saves a new
+    # one under the key
+    def <<(stat)
+      existing_stat = metrics[stat.key]
+      if existing_stat
+        existing_stat.combine!(stat)
+      elsif at_limit?
+        # We're full up, can't add any more.
+        # Should I log this? It may get super noisy?
+      else
+        metrics[stat.key] = stat
+      end
+    end
+
+    def increment_transaction_count!
+      metrics.each do |_key, external_service_metric_stat|
+        external_service_metric_stat.increment_transaction_count!
+      end
+    end
+
+    def metrics_to_report
+      report_limit = context.config.value('external_service_metric_report_limit')
+      if metrics.size > report_limit
+        metrics.
+          values.
+          sort_by {|stat| stat.call_time }.
+          reverse.
+          take(report_limit)
+      else
+        metrics.values
+      end
+    end
+
+    def inspect
+      metrics.map {|key, metric|
+        "#{key.inspect} - Count: #{metric.call_count}, Total Time: #{"%.2f" % metric.call_time}"
+      }.join("\n")
+    end
+
+    def at_limit?
+      @limit ||= context.config.value('external_service_metric_limit')
+      metrics.size >= @limit
+    end
+
+  end
+end

data/lib/scout_apm/external_service_metric_stats.rb

@@ -0,0 +1,85 @@
+module ScoutApm
+  class ExternalServiceMetricStats
+
+    DEFAULT_HISTOGRAM_SIZE = 50
+
+    attr_reader :domain_name
+    attr_reader :operation
+    attr_reader :scope
+
+    attr_reader :transaction_count
+
+    attr_reader :call_count
+    attr_reader :call_time
+
+    attr_reader :min_call_time
+    attr_reader :max_call_time
+
+    attr_reader :histogram
+
+    def initialize(domain_name, operation, scope, call_count, call_time)
+      @domain_name = domain_name
+      @operation = operation
+
+      @call_count = call_count
+
+      @call_time = call_time
+      @min_call_time = call_time
+      @max_call_time = call_time
+
+      # This histogram is for call_time
+      @histogram = NumericHistogram.new(DEFAULT_HISTOGRAM_SIZE)
+      @histogram.add(call_time)
+
+      @transaction_count = 0
+
+      @scope = scope
+    end
+
+    # Merge data in this scope. Used in ExternalServiceMetricSet
+    def key
+      @key ||= [domain_name, operation, scope]
+    end
+
+    # Combine data from another ExternalServiceMetricStats into +self+. Modifies and returns +self+
+    def combine!(other)
+      return self if other == self
+
+      @transaction_count += other.transaction_count
+      @call_count += other.call_count
+      @call_time += other.call_time
+
+      @min_call_time = other.min_call_time if @min_call_time.zero? or other.min_call_time < @min_call_time
+      @max_call_time = other.max_call_time if other.max_call_time > @max_call_time
+
+      @histogram.combine!(other.histogram)
+      self
+    end
+
+    def as_json
+      json_attributes = [
+        :domain_name,
+        :operation,
+        :scope,
+
+        :transaction_count,
+        :call_count,
+
+        :histogram,
+        :call_time,
+        :max_call_time,
+        :min_call_time,
+      ]
+
+      ScoutApm::AttributeArranger.call(self, json_attributes)
+    end
+
+    # Called by the Set on each ExternalServiceMetricStats object that it holds, only
+    # once during the recording of a transaction.
+    #
+    # Don't call elsewhere, and don't set to 1 in the initializer.
+    def increment_transaction_count!
+      @transaction_count += 1
+    end
+  end
+end

data/lib/scout_apm/fake_store.rb

@@ -26,6 +26,9 @@ module ScoutApm
     def track_db_query_metrics!(db_query_metric_set, options={})
     end
 
+    def track_external_service_metrics!(external_service_metric_set, options={})
+    end
+
     def track_slow_transaction!(slow_transaction)
     end
 

data/lib/scout_apm/framework_integrations/rails_3_or_4.rb

@@ -48,6 +48,7 @@ module ScoutApm
           when "sqlite"     then :sqlite
           when "mysql"      then :mysql
           when "mysql2"     then :mysql
+          when "sqlserver"  then :sqlserver
           else default
           end
         else
@@ -70,10 +71,14 @@ module ScoutApm
       #
       # We avoid this issue by not calling .respond_to? here, and instead using the less optimal `rescue nil` approach
       def raw_database_adapter
-        adapter = ActiveRecord::Base.connection_config[:adapter].to_s rescue nil
+        adapter = ActiveRecord::Base.connection_db_config.configuration_hash[:adapter] rescue nil
 
         if adapter.nil?
-          adapter = ActiveRecord::Base.configurations[env]["adapter"]
+          adapter = ActiveRecord::Base.connection_config[:adapter].to_s rescue nil
+        end
+
+        if adapter.nil?
+          adapter = ActiveRecord::Base.configurations.to_h[env]["adapter"]
         end
 
         return adapter

data/lib/scout_apm/git_revision.rb

@@ -20,6 +20,7 @@ module ScoutApm
       detect_from_config     ||
       detect_from_heroku     ||
       detect_from_capistrano ||
+      detect_from_mina ||
       detect_from_git
     end
 
@@ -43,6 +44,14 @@ module ScoutApm
       nil
     end
 
+    # https://github.com/mina-deploy/mina
+    def detect_from_mina 
+      File.read(File.join(app_root, '.mina_git_revision')).strip
+    rescue
+      logger.debug "Unable to detect Git Revision from Mina: #{$!.message}"
+      nil
+    end
+
     def detect_from_git
       if File.directory?(".git")
         `git rev-parse --short HEAD`.strip 

data/lib/scout_apm/ignored_uris.rb

@@ -4,7 +4,9 @@ module ScoutApm
     attr_reader :regex
 
     def initialize(prefixes)
-      regexes = Array(prefixes).map {|prefix| %r{\A#{prefix}} }
+      regexes = Array(prefixes).
+        reject{|prefix| prefix == ""}.
+        map {|prefix| %r{\A#{prefix}} }
       @regex = Regexp.union(*regexes)
     end
 

data/lib/scout_apm/instant/middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: false
+
 module ScoutApm
   module Instant
 
@@ -94,7 +96,8 @@ module ScoutApm
 
       def preconditions_met?
         if dev_trace_disabled?
-          logger.debug("DevTrace: isn't activated via config. Try: SCOUT_DEV_TRACE=true rails server")
+          # The line below is very noise as it is called on every request.
+          # logger.debug("DevTrace: isn't activated via config. Try: SCOUT_DEV_TRACE=true rails server")
           return false
         end
 

data/lib/scout_apm/instrument_manager.rb

@@ -30,8 +30,12 @@ module ScoutApm
       install_instrument(ScoutApm::Instruments::Moped)
       install_instrument(ScoutApm::Instruments::Mongoid)
       install_instrument(ScoutApm::Instruments::NetHttp)
+      install_instrument(ScoutApm::Instruments::Typhoeus)
       install_instrument(ScoutApm::Instruments::HttpClient)
+      install_instrument(ScoutApm::Instruments::HTTP)
+      install_instrument(ScoutApm::Instruments::Memcached)
       install_instrument(ScoutApm::Instruments::Redis)
+      install_instrument(ScoutApm::Instruments::Redis5)
       install_instrument(ScoutApm::Instruments::InfluxDB)
       install_instrument(ScoutApm::Instruments::Elasticsearch)
       install_instrument(ScoutApm::Instruments::Grape)
@@ -47,6 +51,23 @@ module ScoutApm
       (config.value("disabled_instruments") || []).include?(instrument_short_name)
     end
 
+    def prepend_for_instrument?(instrument_klass)
+      instrument_short_name = instrument_klass.name.split("::").last
+
+      # `use_prepend` defaults to false, which means we use `alias_method` by default.
+      # If `use_prepend` is `true`, then we should default to using `prepend` unless
+      # the instrument is explicitly listed in the `alias_method_instruments` config array.
+      if config.value("use_prepend")
+        return false if (config.value("alias_method_instruments") || []).include?(instrument_short_name)
+        return true
+      else
+        # `use_prepend` is false, but we should use `prepend` if the instrument is
+        # explicitly listed in the `prepend_instruments` array.
+        return true if (config.value("prepend_instruments") || []).include?(instrument_short_name)
+        return false
+      end
+    end
+
     private
 
     def install_instrument(instrument_klass)
@@ -59,7 +80,7 @@ module ScoutApm
 
       instance = instrument_klass.new(context)
       @installed_instruments << instance
-      instance.install
+      instance.install(prepend: prepend_for_instrument?(instrument_klass))
     end
 
     def already_installed?(instrument_klass)

data/lib/scout_apm/instruments/action_controller_rails_2.rb

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

data/lib/scout_apm/instruments/action_controller_rails_3_rails4.rb

@@ -17,46 +17,73 @@ module ScoutApm
         @installed
       end
 
-      def install
-        # We previously instrumented ActionController::Metal, which missed
-        # before and after filter timing. Instrumenting Base includes those
-        # filters, at the expense of missing out on controllers that don't use
-        # the full Rails stack.
-        if defined?(::ActionController)
-          @installed = true
+      def installed!
+        @installed = true
+      end
+
+      def install(prepend:)
+        if !defined?(::ActiveSupport)
+          return
+        end
+
+        # The block below runs with `self` equal to the ActionController::Base or ::API module, not this class we're in now. By saving an instance of ourselves into the `this` variable, we can continue accessing what we need.
+        this = self
 
+        ActiveSupport.on_load(:action_controller) do
+          if this.installed?
+            this.logger.info("Skipping ActionController - Already Ran")
+            next
+          else
+            this.logger.info("Instrumenting ActionController (on_load)")
+            this.installed!
+          end
+
+          # We previously instrumented ActionController::Metal, which missed
+          # before and after filter timing. Instrumenting Base includes those
+          # filters, at the expense of missing out on controllers that don't use
+          # the full Rails stack.
           if defined?(::ActionController::Base)
-            logger.info "Instrumenting ActionController::Base"
+            this.logger.info "Instrumenting ActionController::Base"
             ::ActionController::Base.class_eval do
-              # include ScoutApm::Tracer
               include ScoutApm::Instruments::ActionControllerBaseInstruments
             end
           end
 
           if defined?(::ActionController::Metal)
-            logger.info "Instrumenting ActionController::Metal"
+            this.logger.info "Instrumenting ActionController::Metal"
             ::ActionController::Metal.class_eval do
               include ScoutApm::Instruments::ActionControllerMetalInstruments
             end
           end
 
           if defined?(::ActionController::API)
-            logger.info "Instrumenting ActionController::Api"
+            this.logger.info "Instrumenting ActionController::Api"
             ::ActionController::API.class_eval do
               include ScoutApm::Instruments::ActionControllerAPIInstruments
             end
           end
         end
 
-        # Returns a new anonymous module each time it is called. So
-        # we can insert this multiple times into the ancestors
-        # stack. Otherwise it only exists the first time you include it
-        # (under Metal, instead of under API) and we miss instrumenting
-        # before_action callbacks
+        ScoutApm::Agent.instance.context.logger.info("Instrumenting ActionController (hook installed)")
       end
 
+      # Returns a new anonymous module each time it is called. So
+      # we can insert this multiple times into the ancestors
+      # stack. Otherwise it only exists the first time you include it
+      # (under Metal, instead of under API) and we miss instrumenting
+      # before_action callbacks
       def self.build_instrument_module
         Module.new do
+          # Determine the URI of this request to capture. Overridable by users in their controller.
+          def scout_transaction_uri(config=ScoutApm::Agent.instance.context.config)
+            case config.value("uri_reporting")
+            when 'path'
+              request.path # strips off the query string for more security
+            else # default handles filtered params
+              request.filtered_path
+            end
+          end
+
           def process_action(*args)
             req = ScoutApm::RequestManager.lookup
             current_layer = req.current_layer
@@ -68,11 +95,18 @@ module ScoutApm
               req.instant_key = instant_key
             end
 
-            if current_layer && current_layer.type == "Controller"
-              # Don't start a new layer if ActionController::API or ActionController::Base handled it already.
+            # Don't start a new layer if ActionController::API or
+            # ActionController::Base handled it already. Needs to account for
+            # any layers started during a around_action (most likely
+            # AutoInstrument, but could be another custom instrument)
+            if current_layer && (current_layer.type == "Controller" || current_layer.type == "AutoInstrument" || req.web?)
               super
             else
-              req.annotate_request(:uri => ScoutApm::Instruments::ActionControllerRails3Rails4.scout_transaction_uri(request))
+              begin
+                uri = scout_transaction_uri
+                req.annotate_request(:uri => uri)
+              rescue
+              end
 
               # IP Spoofing Protection can throw an exception, just move on w/o remote ip
               if agent_context.config.value('collect_remote_ip')
@@ -95,16 +129,6 @@ module ScoutApm
         end
       end
 
-      # Given an +ActionDispatch::Request+, formats the uri based on config settings.
-      # XXX: Don't lookup context like this - find a way to pass it through
-      def self.scout_transaction_uri(request, config=ScoutApm::Agent.instance.context.config)
-        case config.value("uri_reporting")
-        when 'path'
-          request.path # strips off the query string for more security
-        else # default handles filtered params
-          request.filtered_path
-        end
-      end
     end
 
     module ActionControllerMetalInstruments

data/lib/scout_apm/instruments/action_view.rb

@@ -29,7 +29,7 @@ module ScoutApm
         context.environment.supports_module_prepend?
       end
 
-      def install
+      def install(prepend:)
         return unless defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
 
         if prependable?
@@ -75,28 +75,40 @@ module ScoutApm
       end
 
       module ActionViewPartialRendererInstruments
-        def render_partial(*args)
+        # In Rails 6, the signature changed to pass the view & template args directly, as opposed to through the instance var
+        # New signature is: def render_partial(view, template)
+        def render_partial(*args, **kwargs)
           req = ScoutApm::RequestManager.lookup
 
-          template_name = @template.virtual_path rescue "Unknown Partial"
+          maybe_template = args[1]
+
+          template_name = @template.virtual_path rescue nil        # Works on Rails 3.2 -> end of Rails 5 series
+          template_name ||= maybe_template.virtual_path rescue nil # Works on Rails 6 -> 6.0.3.5
           template_name ||= "Unknown Partial"
-          layer_name = template_name + "/Rendering"
 
+          layer_name = template_name + "/Rendering"
           layer = ScoutApm::Layer.new("View", layer_name)
           layer.subscopable!
 
           begin
             req.start_layer(layer)
-            super(*args)
+            if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+              super(*args, **kwargs)
+            else
+              super(*args)
+            end
           ensure
             req.stop_layer
           end
         end
 
-        def collection_with_template(*args)
+        def collection_with_template(*args, **kwargs)
           req = ScoutApm::RequestManager.lookup
 
-          template_name = @template.virtual_path rescue "Unknown Collection"
+          maybe_template = args[1]
+
+          template_name = @template.virtual_path rescue nil # Works on Rails 3.2 -> end of Rails 5 series
+          template_name ||= maybe_template.virtual_path rescue nil # Works on Rails 6 -> 6.0.3.5
           template_name ||= "Unknown Collection"
           layer_name = template_name + "/Rendering"
 
@@ -105,7 +117,11 @@ module ScoutApm
 
           begin
             req.start_layer(layer)
-            super(*args)
+            if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+              super(*args, **kwargs)
+            else
+              super(*args)
+            end
           ensure
             req.stop_layer
           end
@@ -113,10 +129,15 @@ module ScoutApm
       end
 
       module ActionViewTemplateRendererInstruments
+        # Don't forward kwargs here, since Rails 3, 4, 5, 6 don't use them, and
+        # it causes annoyances in the instrumentation
         def render_template(*args)
           req = ScoutApm::RequestManager.lookup
 
-          template_name = args[0].virtual_path rescue "Unknown"
+          maybe_template = args[1]
+
+          template_name = args[0].virtual_path rescue nil # Works on Rails 3.2 -> end of Rails 5 series
+          template_name ||= maybe_template.virtual_path rescue nil # Works on Rails 6 -> 6.1.3
           template_name ||= "Unknown"
           layer_name = template_name + "/Rendering"