scout_apm 3.0.0.pre27 → 4.0.3

data/lib/scout_apm/limited_layer.rb

@@ -85,13 +85,6 @@ module ScoutApm
       nil
     end
 
-    def add_traces(*)
-      # noop
-    end
-
-    def traces
-      ScoutApm::TraceSet.new
-    end
 
     #######################################################################
     #  Many methods don't make any sense on a limited layer. Raise errors  #

data/lib/scout_apm/metric_stats.rb

@@ -9,7 +9,6 @@ class MetricStats
   attr_accessor :sum_of_squares
   attr_accessor :queue
   attr_accessor :latency
-  attr_accessor :traces
 
   def initialize(scoped = false)
     @scoped = scoped
@@ -19,7 +18,6 @@ class MetricStats
     self.min_call_time = 0.0
     self.max_call_time = 0.0
     self.sum_of_squares = 0.0
-    self.traces = []
   end
 
   # Note, that you must include exclusive_time if you wish to set
@@ -41,10 +39,6 @@ class MetricStats
     self
   end
 
-  def add_traces(traces)
-    self.traces += Array(traces)
-  end
-
   # combines data from another MetricStats object
   def combine!(other)
     self.call_count += other.call_count
@@ -53,7 +47,6 @@ class MetricStats
     self.min_call_time = other.min_call_time if self.min_call_time.zero? or other.min_call_time < self.min_call_time
     self.max_call_time = other.max_call_time if other.max_call_time > self.max_call_time
     self.sum_of_squares += other.sum_of_squares
-    self.traces = Array(self.traces) + Array(other.traces)
     self
   end
 
@@ -64,7 +57,6 @@ class MetricStats
       :min_call_time,
       :total_call_time,
       :total_exclusive_time,
-      :traces,
     ]
     ScoutApm::AttributeArranger.call(self, json_attributes)
   end

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/periodic_work.rb

@@ -12,10 +12,29 @@ module ScoutApm
       ScoutApm::Debug.instance.call_periodic_hooks
       @reporting.process_metrics
       clean_old_percentiles
+
+      if context.config.value('auto_instruments')
+        log_autoinstrument_significant_counts rescue nil
+      end
     end
 
     private
 
+    def log_autoinstrument_significant_counts
+      # Ex key/value -
+      # "/Users/dlite/projects/scout/apm/app/controllers/application_controller.rb"=>[[0.0, 689], [1.0, 16]]
+      hists = context.auto_instruments_layer_histograms.as_json
+      hists_summary = hists.map { |file, buckets|
+        total = buckets.map(&:last).inject(0) { |sum, count| sum + count }
+        significant = (buckets.last.last / total.to_f).round(2)
+        [
+          file,
+          {:total => total, :significant => significant}
+        ]
+      }.to_h
+      context.logger.debug("AutoInstrument Significant Layer Histograms: #{hists_summary.pretty_inspect}")
+    end
+
     # XXX: Move logic into a RequestHistogramsByTime class that can keep the timeout logic in it
     def clean_old_percentiles
       context.

data/lib/scout_apm/remote/message.rb

@@ -17,6 +17,10 @@ module ScoutApm
 
       def encode
         Marshal.dump(self)
+      rescue
+        ScoutApm::Agent.instance.logger.info("Failed Marshalling Remote::Message")
+        ScoutApm::Agent.instance.logger.info(ScoutApm::Utils::MarshalLogging.new(self).dive) rescue nil
+        raise
       end
     end
   end

data/lib/scout_apm/remote/server.rb

@@ -16,8 +16,20 @@ module ScoutApm
         @server = nil
       end
 
-      def start
+      def require_webrick
         require 'webrick'
+        true
+      rescue LoadError
+        @logger.warn(
+          %q|Could not require Webrick. Ruby 3.0 stopped bundling it
+             automatically, but it is required to instrument Resque. Please add
+             Webrick to your Gemfile.|
+        )
+        false
+      end
+
+      def start
+        return false unless require_webrick
 
         @server = WEBrick::HTTPServer.new(
           :BindAddress => bind,

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/reporting.rb

@@ -83,10 +83,11 @@ module ScoutApm
       slow_jobs = reporting_period.slow_jobs_payload
       histograms = reporting_period.histograms
       db_query_metrics = reporting_period.db_query_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)
+      payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, traces)
       logger.debug("Sending payload w/ Headers: #{headers.inspect}")
 
       reporter.report(payload, headers)

data/lib/scout_apm/request_histograms.rb

@@ -22,6 +22,14 @@ module ScoutApm
       @histograms.keys.each { |n| yield n }
     end
 
+    def as_json
+      Hash[
+        @histograms.map{ |key, histogram|
+          [key, histogram.as_json]
+        }
+      ]
+    end
+
     def add(item, value)
       @histograms[item].add(value)
     end

data/lib/scout_apm/serializers/app_server_load_serializer.rb

@@ -5,6 +5,10 @@ module ScoutApm
     class AppServerLoadSerializer
       def self.serialize(data)
         Marshal.dump(data)
+      rescue
+        ScoutApm::Agent.instance.logger.info("Failed Marshalling AppServerLoad")
+        ScoutApm::Agent.instance.logger.info(ScoutApm::Utils::MarshalLogging.new(data).dive) rescue nil
+        raise
       end
 
       def self.deserialize(data)

data/lib/scout_apm/serializers/directive_serializer.rb

@@ -5,6 +5,10 @@ module ScoutApm
     class DirectiveSerializer
       def self.serialize(data)
         Marshal.dump(data)
+      rescue
+        ScoutApm::Agent.instance.logger.info("Failed Marshalling Directive")
+        ScoutApm::Agent.instance.logger.info(ScoutApm::Utils::MarshalLogging.new(data).dive) rescue nil
+        raise
       end
 
       def self.deserialize(data)

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)
+      def self.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_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)
+          ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, traces)
         else
           metadata = metadata.dup
           metadata.default = nil

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)
+        def serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics, traces)
           metadata.merge!({:payload_version => 2})
 
           jsonify_hash({:metadata => metadata,
@@ -14,6 +14,7 @@ module ScoutApm
                         :db_metrics => {
                           :query => DbQuerySerializerToJson.new(db_query_metrics).as_json,
                         },
+                        :span_traces => traces.map{ |t| t.as_json },
           })
         end
 
@@ -44,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)
@@ -71,10 +90,6 @@ module ScoutApm
             %Q["#{formatee.iso8601}"]
           when nil
             "null"
-          when TrueClass
-            "true"
-          when FalseClass
-            "false"
           else # strings and everything
             %Q["#{escape(formatee)}"]
           end

data/lib/scout_apm/slow_job_record.rb

@@ -23,7 +23,9 @@ module ScoutApm
     attr_reader :git_sha
     attr_reader :truncated_metrics
 
-    def initialize(agent_context, queue_name, job_name, time, total_time, exclusive_time, context, metrics, allocation_metrics, mem_delta, allocations, score, truncated_metrics)
+    attr_reader :span_trace
+
+    def initialize(agent_context, queue_name, job_name, time, total_time, exclusive_time, context, metrics, allocation_metrics, mem_delta, allocations, score, truncated_metrics, span_trace)
       @queue_name = queue_name
       @job_name = job_name
       @time = time
@@ -40,6 +42,8 @@ module ScoutApm
       @score = score
       @truncated_metrics = truncated_metrics
 
+      @span_trace = span_trace
+
       agent_context.logger.debug { "Slow Job [#{metric_name}] - Call Time: #{total_call_time} Mem Delta: #{mem_delta}"}
     end
 

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