scout_apm 2.6.6 → 4.0.0

data/lib/scout_apm/instruments/active_record.rb

@@ -82,15 +82,8 @@ module ScoutApm
 
         # Install #log tracing
         if Utils::KlassHelper.defined?("ActiveRecord::ConnectionAdapters::AbstractAdapter")
-          if Module.respond_to?(:prepend)
-            ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecordInstruments)
-            ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Tracer)
-          else
-            ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-              include ::ScoutApm::Instruments::ActiveRecordAliasMethodInstruments
-              include ::ScoutApm::Tracer
-            end
-          end
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecordInstruments)
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Tracer)
         end
 
         if Utils::KlassHelper.defined?("ActiveRecord::Base")
@@ -172,20 +165,12 @@ module ScoutApm
     # to the real SQL, and an AR generated "name" for the Query
     #
     ################################################################################
-    #
-    # Note, if you change this instrumentation, you also need to change ActiveRecordInstruments.
-    module ActiveRecordAliasMethodInstruments
-      def self.included(instrumented_class)
+    module ActiveRecordInstruments
+      def self.prepended(instrumented_class)
         ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
-        instrumented_class.class_eval do
-          unless instrumented_class.method_defined?(:log_without_scout_instruments)
-            alias_method :log_without_scout_instruments, :log
-            alias_method :log, :log_with_scout_instruments
-          end
-        end
       end
 
-      def log_with_scout_instruments(*args, &block)
+      def log(*args, &block)
         # Extract data from the arguments
         sql, name = args
         metric_name = Utils::ActiveRecordMetricName.new(sql, name)
@@ -216,7 +201,7 @@ module ScoutApm
           end
           current_layer.desc.merge(desc)
 
-          log_without_scout_instruments(*args, &block)
+          super(*args, &block)
 
         # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
         else
@@ -224,7 +209,7 @@ module ScoutApm
           layer.desc = desc
           req.start_layer(layer)
           begin
-            log_without_scout_instruments(*args, &block)
+            super(*args, &block)
           ensure
             req.stop_layer
           end
@@ -323,14 +308,14 @@ module ScoutApm
         end
       end
 
-      def find_by_sql_with_scout_instruments(*args, &block)
+      def find_by_sql_with_scout_instruments(*args, **kwargs, &block)
         req = ScoutApm::RequestManager.lookup
         layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName::DEFAULT_METRIC)
         layer.annotate_layer(:ignorable => true)
         req.start_layer(layer)
         req.ignore_children!
         begin
-          find_by_sql_without_scout_instruments(*args, &block)
+          find_by_sql_without_scout_instruments(*args, **kwargs, &block)
         ensure
           req.acknowledge_children!
           req.stop_layer
@@ -408,7 +393,7 @@ module ScoutApm
     end
 
     module ActiveRecordUpdateInstruments
-      def save(*args, &block)
+      def save(*args, **options, &block)
         model = self.class.name
         operation = self.persisted? ? "Update" : "Create"
 
@@ -418,14 +403,14 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          super(*args, &block)
+          super(*args, **options, &block)
         ensure
           req.acknowledge_children!
           req.stop_layer
         end
       end
 
-      def save!(*args, &block)
+      def save!(*args, **options, &block)
         model = self.class.name
         operation = self.persisted? ? "Update" : "Create"
 
@@ -434,7 +419,7 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          super(*args, &block)
+          super(*args, **options, &block)
         ensure
           req.acknowledge_children!
           req.stop_layer

data/lib/scout_apm/middleware.rb

@@ -26,7 +26,7 @@ module ScoutApm
       ScoutApm::Agent.instance.start
       @started = ScoutApm::Agent.instance.context.started? && ScoutApm::Agent.instance.background_worker_running?
     rescue => e
-      ScoutApm::Agent.instance.context.logger("Failed to start via Middleware: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+      ScoutApm::Agent.instance.context.logger.info("Failed to start via Middleware: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
     end
   end
 end

data/lib/scout_apm/reporter.rb

@@ -2,7 +2,6 @@ require 'openssl'
 
 module ScoutApm
   class Reporter
-    CA_FILE     = File.join( File.dirname(__FILE__), *%w[.. .. data cacert.pem] )
     VERIFY_MODE = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
 
     attr_reader :type
@@ -23,6 +22,7 @@ module ScoutApm
       context.logger
     end
 
+    # The fully serialized string payload to be sent
     def report(payload, headers = {})
       hosts = determine_hosts
 
@@ -36,6 +36,7 @@ module ScoutApm
         logger.debug("Original Size: #{original_payload_size} Compressed Size: #{compress_payload_size}")
       end
 
+      logger.info("Posting payload to #{hosts.inspect}")
       post_payload(hosts, payload, headers)
     end
 
@@ -52,6 +53,8 @@ module ScoutApm
         URI.parse("#{host}/apps/deploy.scout?key=#{key}&name=#{encoded_app_name}")
       when :instant_trace
         URI.parse("#{host}/apps/instant_trace.scout?key=#{key}&name=#{encoded_app_name}&instant_key=#{instant_key}")
+      when :errors
+        URI.parse("#{host}/apps/error.scout?key=#{key}&name=#{encoded_app_name}")
       end.tap { |u| logger.debug("Posting to #{u}") }
     end
 
@@ -90,7 +93,7 @@ module ScoutApm
       logger.debug "got response: #{response.inspect}"
       case response
       when Net::HTTPSuccess, Net::HTTPNotModified
-        logger.debug "/#{type} OK"
+        logger.debug "#{type} OK"
       when Net::HTTPBadRequest
         logger.warn "/#{type} FAILED: The Account Key [#{config.value('key')}] is invalid."
       when Net::HTTPUnprocessableEntity
@@ -123,7 +126,7 @@ module ScoutApm
                               proxy_uri.password).new(url.host, url.port)
       if url.is_a?(URI::HTTPS)
         http.use_ssl = true
-        http.ca_file = CA_FILE
+        http.ca_file = config.value("ssl_cert_file")
         http.verify_mode = VERIFY_MODE
       end
       http
@@ -142,6 +145,8 @@ module ScoutApm
     def determine_hosts
       if [:deploy_hook, :instant_trace].include?(type)
         config.value('direct_host')
+      elsif [:errors].include?(type)
+        config.value('errors_host')
       else
         config.value('host')
       end

data/lib/scout_apm/serializers/payload_serializer_to_json.rb

@@ -45,18 +45,36 @@ module ScoutApm
           "{#{str_parts.join(",")}}"
         end
 
-        ESCAPE_MAPPINGS = {
-          "\b" => '\\b',
-          "\t" => '\\t',
-          "\n" => '\\n',
-          "\f" => '\\f',
-          "\r" => '\\r',
-          '"'  => '\\"',
-          '\\' => '\\\\',
-        }
+        # Ruby 1.8.7 seems to be fundamentally different in how gsub or regexes
+        # work. This is a hack and will be removed as soon as we can drop
+        # support
+        if RUBY_VERSION == "1.8.7"
+          ESCAPE_MAPPINGS = {
+            "\b" => '\\b',
+            "\t" => '\\t',
+            "\n" => '\\n',
+            "\f" => '\\f',
+            "\r" => '\\r',
+            '"'  => '\\"',
+            '\\' => '\\\\',
+          }
+        else
+          ESCAPE_MAPPINGS = {
+            # Stackoverflow answer on gsub matches and backslashes - https://stackoverflow.com/a/4149087/2705125
+            '\\' => '\\\\\\\\',
+            "\b" => '\\b',
+            "\t" => '\\t',
+            "\n" => '\\n',
+            "\f" => '\\f',
+            "\r" => '\\r',
+            '"'  => '\\"',
+          }
+        end
 
         def escape(string)
-          ESCAPE_MAPPINGS.inject(string.to_s) {|s, (bad, good)| s.gsub(bad, good) }
+          ESCAPE_MAPPINGS.inject(string.to_s) {|s, (bad, good)| 
+            s.gsub(bad, good)
+          }
         end
 
         def format_by_type(formatee)

data/lib/scout_apm/slow_policy/age_policy.rb

@@ -0,0 +1,33 @@
+require 'scout_apm/slow_policy/policy'
+
+module ScoutApm::SlowPolicy
+  class AgePolicy < Policy
+    # For each minute we haven't seen an endpoint
+    POINT_MULTIPLIER_AGE = 0.25
+
+    # A hash of Endpoint Name to the last time we stored a slow transaction for it.
+    #
+    # Defaults to a start time that is pretty close to application boot time.
+    # So the "age" of an endpoint we've never seen is the time the application
+    # has been running.
+    attr_reader :last_seen
+
+    def initialize(context)
+      super
+
+      zero_time = Time.now
+      @last_seen = Hash.new { |h, k| h[k] = zero_time }
+    end
+
+    def call(request)
+      # How long has it been since we've seen this?
+      age = Time.now - last_seen[request.unique_name]
+
+      age / 60.0 * POINT_MULTIPLIER_AGE
+    end
+
+    def stored!(request)
+      last_seen[request.unique_name] = Time.now
+    end
+  end
+end

data/lib/scout_apm/slow_policy/percent_policy.rb

@@ -0,0 +1,22 @@
+require 'scout_apm/slow_policy/policy'
+
+module ScoutApm::SlowPolicy
+  class PercentPolicy < Policy
+    # Points for an endpoint's who's throughput * response time is a large % of
+    # overall time spent processing requests
+    POINT_MULTIPLIER_PERCENT_TIME = 2.5
+
+    # Of the total time spent handling endpoints in this app, if this endpoint
+    # is a higher percent, it should get more points.
+    #
+    # A: 20 calls @ 100ms each => 2 seconds of total time
+    # B: 10 calls @ 100ms each => 1 second of total time
+    #
+    # Then A is 66% of the total call time
+    def call(request) # Scale 0.0 - 1.0
+      percent = context.transaction_time_consumed.percent_of_total(request.unique_name)
+
+      percent * POINT_MULTIPLIER_PERCENT_TIME
+    end
+  end
+end

data/lib/scout_apm/slow_policy/percentile_policy.rb

@@ -0,0 +1,24 @@
+require 'scout_apm/slow_policy/policy'
+
+module ScoutApm::SlowPolicy
+  class PercentilePolicy < Policy
+    def call(request)
+      # What approximate percentile was this request?
+      total_time = request.root_layer.total_call_time
+      percentile = context.request_histograms.approximate_quantile_of_value(request.unique_name, total_time)
+
+      if percentile < 40
+        0.4 # Don't put much emphasis on capturing low percentiles.
+      elsif percentile < 60
+        1.4 # Highest here to get mean traces
+      elsif percentile < 90
+        0.7 # Between 60 & 90% is fine.
+      elsif percentile >= 90
+        1.4 # Highest here to get 90+%ile traces
+      else
+        # impossible.
+        percentile
+      end
+    end
+  end
+end

data/lib/scout_apm/slow_policy/policy.rb

@@ -0,0 +1,21 @@
+# Note that this is semi-internal API. You should not need this, and if you do
+# we're here to help at support@scoutapm.com. TrackedRequest doesn't change
+# often, but we can't promise a perfectly stable API for it either.
+module ScoutApm::SlowPolicy
+  class Policy
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+    end
+
+    def call(request)
+      raise NotImplementedError
+    end
+
+    # Override in subclasses to execute some behavior if the request gets a
+    # slot in the ScoredItemSet. Defaults to no-op
+    def stored!(request)
+    end
+  end
+end

data/lib/scout_apm/slow_policy/speed_policy.rb

@@ -0,0 +1,16 @@
+require 'scout_apm/slow_policy/policy'
+
+module ScoutApm::SlowPolicy
+  class SpeedPolicy < Policy
+    # Adjust speed points. See the function
+    POINT_MULTIPLIER_SPEED = 0.25
+
+    # Time in seconds
+    # Logarithm keeps huge times from swamping the other metrics.
+    # 1+ is necessary to keep the log function in positive territory.
+    def call(request)
+      total_time = request.root_layer.total_call_time
+      Math.log(1 + total_time) * POINT_MULTIPLIER_SPEED
+    end
+  end
+end

data/lib/scout_apm/slow_request_policy.rb

@@ -3,43 +3,29 @@
 
 module ScoutApm
   class SlowRequestPolicy
-    CAPTURE_TYPES = [
-      CAPTURE_DETAIL  = "capture_detail",
-      CAPTURE_NONE    = "capture_none",
-    ]
-
-    # Adjust speed points. See the function
-    POINT_MULTIPLIER_SPEED = 0.25
-
-    # For each minute we haven't seen an endpoint
-    POINT_MULTIPLIER_AGE = 0.25
-
-    # Outliers are worth up to "1000ms" of weight
-    POINT_MULTIPLIER_PERCENTILE = 1.0
-
-    # Points for an endpoint's who's throughput * response time is a large % of
-    # overall time spent processing requests
-    POINT_MULTIPLIER_PERCENT_TIME = 2.5
-
-    # A hash of Endpoint Name to the last time we stored a slow transaction for it.
-    #
-    # Defaults to a start time that is pretty close to application boot time.
-    # So the "age" of an endpoint we've never seen is the time the application
-    # has been running.
-    attr_reader :last_seen
-
     # The AgentContext we're running in
     attr_reader :context
+    attr_reader :policies
 
     def initialize(context)
       @context = context
+      @policies = []
+    end
 
-      zero_time = Time.now
-      @last_seen = Hash.new { |h, k| h[k] = zero_time }
+    def add_default_policies
+      add(SlowPolicy::SpeedPolicy.new(context))
+      add(SlowPolicy::PercentilePolicy.new(context))
+      add(SlowPolicy::AgePolicy.new(context))
+      add(SlowPolicy::PercentilePolicy.new(context))
     end
 
-    def stored!(request)
-      last_seen[request.unique_name] = Time.now
+    # policy is an object that behaves like a policy (responds to .call(req) for the score, and .store!(req))
+    def add(policy)
+      unless policy.respond_to?(:call) && policy.respond_to?(:stored!)
+        raise "SlowRequestPolicy must implement policy api call(req) and stored!(req)"
+      end
+
+      @policies << policy
     end
 
     # Determine if this request trace should be fully analyzed by scoring it
@@ -56,56 +42,11 @@ module ScoutApm
         return -1 # A negative score, should never be good enough to store.
       end
 
-      total_time = request.root_layer.total_call_time
-
-      # How long has it been since we've seen this?
-      age = Time.now - last_seen[unique_name]
-
-      # What approximate percentile was this request?
-      percentile = context.request_histograms.approximate_quantile_of_value(unique_name, total_time)
-
-      percent_of_total_time = context.transaction_time_consumed.percent_of_total(unique_name)
-
-      return speed_points(total_time) + percentile_points(percentile) + age_points(age) + percent_time_points(percent_of_total_time)
-    end
-
-    private
-
-    # Time in seconds
-    # Logarithm keeps huge times from swamping the other metrics.
-    # 1+ is necessary to keep the log function in positive territory.
-    def speed_points(time)
-      Math.log(1 + time) * POINT_MULTIPLIER_SPEED
-    end
-
-    def percentile_points(percentile)
-      if percentile < 40
-        0.4 # Don't put much emphasis on capturing low percentiles.
-      elsif percentile < 60
-        1.4 # Highest here to get mean traces
-      elsif percentile < 90
-        0.7 # Between 60 & 90% is fine.
-      elsif percentile >= 90
-        1.4 # Highest here to get 90+%ile traces
-      else
-        # impossible.
-        percentile
-      end
-    end
-
-    def age_points(age)
-      age / 60.0 * POINT_MULTIPLIER_AGE
+      policies.map{ |p| p.call(request) }.sum
     end
 
-    # Of the total time spent handling endpoints in this app, if this endpoint
-    # is a higher percent, it should get more points.
-    #
-    # A: 20 calls @ 100ms each => 2 seconds of total time
-    # B: 10 calls @ 100ms each => 1 second of total time
-    #
-    # Then A is 66% of the total call time
-    def percent_time_points(percent) # Scale 0.0 - 1.0
-      percent * POINT_MULTIPLIER_PERCENT_TIME
+    def stored!(request)
+      policies.each{ |p| p.stored!(request) }
     end
   end
 end