scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/layer_converters/slow_request_converter.rb

@@ -1,48 +1,46 @@
 module ScoutApm
   module LayerConverters
     class SlowRequestConverter < ConverterBase
-      ###################
-      #  Converter API  #
-      ###################
-      def record!
-        return nil unless request.web?
-        @points = context.slow_request_policy.score(request)
-
-        # Let the store know we're here, and if it wants our data, it will call
-        # back into #call
-        @store.track_slow_transaction!(self)
-
-        nil # not returning anything in the layer results ... not used
+      def initialize(*)
+        @backtraces = [] # An Array of MetricMetas that have a backtrace
+        super
+
+        # After call to super, so @request is populated
+        @points = if request.web?
+                    ScoutApm::Agent.instance.slow_request_policy.score(request)
+                  else
+                    -1
+                  end
       end
 
-      #####################
-      #  ScoreItemSet API #
-      #####################
-      def name; request.unique_name; end
-      def score; @points; end
+      def name
+        request.unique_name
+      end
+
+      def score
+        @points
+      end
 
       # Unconditionally attempts to convert this into a SlowTransaction object.
       # Can return nil if the request didn't have any scope_layer.
       def call
-        return nil unless request.web?
-        return nil unless scope_layer
+        scope = scope_layer
+        return nil unless scope
 
-        context.slow_request_policy.stored!(request)
+        ScoutApm::Agent.instance.slow_request_policy.stored!(request)
 
         # record the change in memory usage
-        mem_delta = ScoutApm::Instruments::Process::ProcessMemory.new(context).rss_to_mb(@request.capture_mem_delta!)
+        mem_delta = ScoutApm::Instruments::Process::ProcessMemory.rss_to_mb(@request.capture_mem_delta!)
 
         uri = request.annotations[:uri] || ""
 
         timing_metrics, allocation_metrics = create_metrics
-
         unless ScoutApm::Instruments::Allocations::ENABLED
           allocation_metrics = {}
         end
 
-        SlowTransaction.new(context,
-                            uri,
-                            scope_layer.legacy_metric_name,
+        SlowTransaction.new(uri,
+                            scope.legacy_metric_name,
                             root_layer.total_call_time,
                             timing_metrics,
                             allocation_metrics,
@@ -51,48 +49,119 @@ module ScoutApm
                             [], # stackprof, now unused.
                             mem_delta,
                             root_layer.total_allocations,
-                            @points,
-                            limited?,
-                            span_trace)
+                            @points)
+      end
+
+      # Iterates over the TrackedRequest's MetricMetas that have backtraces and attaches each to correct MetricMeta in the Metric Hash.
+      def attach_backtraces(metric_hash)
+        @backtraces.each do |meta_with_backtrace|
+          metric_hash.keys.find { |k| k == meta_with_backtrace }.backtrace = meta_with_backtrace.backtrace
+        end
+        metric_hash
       end
 
       # Full metrics from this request. These get stored permanently in a SlowTransaction.
       # Some merging of metrics will happen here, so if a request calls the same
       # ActiveRecord or View repeatedly, it'll get merged.
-      #
+      # 
       # This returns a 2-element of Metric Hashes (the first element is timing metrics, the second element is allocation metrics)
       def create_metrics
-        # Create a new walker, and wire up the subscope stuff
-        walker = LayerConverters::DepthFirstWalker.new(self.root_layer)
-        register_hooks(walker)
-
         metric_hash = Hash.new
         allocation_metric_hash = Hash.new
 
-        walker.on do |layer|
-          next if skip_layer?(layer)
-          store_specific_metric(layer, metric_hash, allocation_metric_hash)
-          store_aggregate_metric(layer, metric_hash, allocation_metric_hash)
+        # Keep a list of subscopes, but only ever use the front one.  The rest
+        # get pushed/popped in cases when we have many levels of subscopable
+        # layers.  This lets us push/pop without otherwise keeping track very closely.
+        subscope_layers = []
+
+        walker.before do |layer|
+          if layer.subscopable?
+            subscope_layers.push(layer)
+          end
         end
 
-        # And now run through the walk we just defined
-        walker.walk
+        walker.after do |layer|
+          if layer.subscopable?
+            subscope_layers.pop
+          end
+        end
+
+        walker.walk do |layer|
+          # Sometimes we start capturing a layer without knowing if we really
+          # want to make an entry for it.  See ActiveRecord instrumentation for
+          # an example. We start capturing before we know if a query is cached
+          # or not, and want to skip any cached queries.
+          if layer.annotations[:ignorable]
+            next
+          end
+
+          meta_options = if subscope_layers.first && layer != subscope_layers.first # Don't scope under ourself.
+                           subscope_name = subscope_layers.first.legacy_metric_name
+                           {:scope => subscope_name}
+                         elsif layer == scope_layer # We don't scope the controller under itself
+                           {}
+                         else
+                           {:scope => scope_layer.legacy_metric_name}
+                         end
+
+          # Specific Metric
+          meta_options.merge!(:desc => layer.desc.to_s) if layer.desc
+          meta = MetricMeta.new(layer.legacy_metric_name, meta_options)
+          meta.extra.merge!(layer.annotations)
+          if layer.backtrace
+            bt = ScoutApm::Utils::BacktraceParser.new(layer.backtrace).call
+            if bt.any? # we could walk thru the call stack and not find in-app code
+              meta.backtrace = bt
+              # Why not just call meta.backtrace and call it done? The walker
+              # could access a later later that generates the same MetricMeta
+              # but doesn't have a backtrace. This could be lost in the
+              # metric_hash if it is replaced by the new key.
+              @backtraces << meta
+            else
+              ScoutApm::Agent.instance.logger.debug { "Unable to capture an app-specific backtrace for #{meta.inspect}\n#{layer.backtrace}" }
+            end
+          end
+          metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
+          allocation_metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
+          # timing
+          stat = metric_hash[meta]
+          stat.update!(layer.total_call_time, layer.total_exclusive_time)
+          stat.add_traces(layer.traces.as_json)
+
+          # Debug logging for scoutprof traces
+          if ScoutApm::Agent.instance.config.value('profile')
+            if layer.type =~ %r{^(Controller|Queue|Job)$}.freeze
+              ScoutApm::Agent.instance.logger.debug do
+                traces_inspect = layer.traces.inspect
+                "****** Slow Request #{layer.type} Traces (#{layer.name}, tet: #{layer.total_exclusive_time}, tct: #{layer.total_call_time}), total raw traces: #{layer.traces.cube.total_count}, total clean traces: #{layer.traces.total_count}, skipped gc: #{layer.traces.skipped_in_gc}, skipped handler: #{layer.traces.skipped_in_handler}, skipped registered #{layer.traces.skipped_in_job_registered}, skipped not_running #{layer.traces.skipped_in_not_running}:\n#{traces_inspect}"
+              end
+            end
+          else
+            if layer.type =~ %r{^(Controller|Queue|Job)$}.freeze
+              ScoutApm::Agent.instance.logger.debug "****** Slow Request #{layer.type} Traces: Scoutprof is not enabled"
+            end
+          end
+
+          # allocations
+          stat = allocation_metric_hash[meta]
+          stat.update!(layer.total_allocations, layer.total_exclusive_allocations)
+
+          # Merged Metric (no specifics, just sum up by type)
+          meta = MetricMeta.new("#{layer.type}/all")
+          metric_hash[meta] ||= MetricStats.new(false)
+          allocation_metric_hash[meta] ||= MetricStats.new(false)
+          # timing
+          stat = metric_hash[meta]
+          stat.update!(layer.total_call_time, layer.total_exclusive_time)
+          # allocations
+          stat = allocation_metric_hash[meta]
+          stat.update!(layer.total_allocations, layer.total_exclusive_allocations)
+        end
 
         metric_hash = attach_backtraces(metric_hash)
         allocation_metric_hash = attach_backtraces(allocation_metric_hash)
 
-        [metric_hash, allocation_metric_hash]
-      end
-
-      ###########################################################
-      #  Also create a new style trace. This is not a good      #
-      #  spot for this long term, but fixes an issue for now.   #
-      ###########################################################
-      
-      def span_trace
-        ScoutApm::LayerConverters::TraceConverter.
-          new(@context, @request, @layer_finder, @store).
-          call
+        [metric_hash,allocation_metric_hash]
       end
     end
   end

data/lib/scout_apm/metric_meta.rb

@@ -33,6 +33,11 @@ class MetricMeta
     !!(metric_name =~ /\A(Controller|Job)\//)
   end
 
+  # To avoid conflicts with different JSON libaries
+  def to_json(*a)
+     %Q[{"metric_id":#{metric_id || 'null'},"metric_name":#{metric_name.to_json},"scope":#{scope.to_json || 'null'}}]
+  end
+
   def ==(o)
     self.eql?(o)
   end

data/lib/scout_apm/metric_set.rb

@@ -1,8 +1,6 @@
 module ScoutApm
   class MetricSet
-    # We can't aggregate a handful of things like samplers (CPU, Memory), or
-    # Controller, and Percentiles so pass through these metrics directly
-    #
+    # We can't aggregate CPU, Memory, Capacity, or Controller, so pass through these metrics directly
     # TODO: Figure out a way to not have this duplicate what's in Samplers, and also on server's ingest
     PASSTHROUGH_METRICS = ["CPU", "Memory", "Instance", "Controller", "SlowTransaction", "Percentile", "Job"]
 
@@ -51,11 +49,5 @@ module ScoutApm
       @combine_in_progress = false
       self
     end
-
-
-    def eql?(other)
-      metrics == other.metrics
-    end
-    alias :== :eql?
   end
 end

data/lib/scout_apm/metric_stats.rb

@@ -9,6 +9,7 @@ class MetricStats
   attr_accessor :sum_of_squares
   attr_accessor :queue
   attr_accessor :latency
+  attr_accessor :traces
 
   def initialize(scoped = false)
     @scoped = scoped
@@ -18,6 +19,7 @@ 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
@@ -39,6 +41,10 @@ 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
@@ -47,17 +53,12 @@ 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
 
   def as_json
-    json_attributes = [
-      :call_count,
-      :max_call_time,
-      :min_call_time,
-      :total_call_time,
-      :total_exclusive_time,
-    ]
+    json_attributes = [:call_count, :total_call_time, :total_exclusive_time, :min_call_time, :max_call_time, :traces]
     ScoutApm::AttributeArranger.call(self, json_attributes)
   end
 end

data/lib/scout_apm/middleware.rb

@@ -5,10 +5,8 @@ module ScoutApm
     def initialize(app)
       @app = app
       @attempts = 0
-      # @enabled = ScoutApm::Agent.instance.context.apm_enabled?
-      # XXX: Figure out if this middleware should even know
-      @enabled = true
-      @started = ScoutApm::Agent.instance.context.started? && ScoutApm::Agent.instance.background_worker_running?
+      @enabled = ScoutApm::Agent.instance.apm_enabled?
+      @started = ScoutApm::Agent.instance.started? && ScoutApm::Agent.instance.background_worker_running?
     end
 
     # If we get a web request in, then we know we're running in some sort of app server
@@ -23,10 +21,14 @@ module ScoutApm
 
     def attempt_to_start_agent
       @attempts += 1
-      ScoutApm::Agent.instance.start
-      @started = ScoutApm::Agent.instance.context.started? && ScoutApm::Agent.instance.background_worker_running?
+      ScoutApm::Agent.instance.start(:skip_app_server_check => true)
+      ScoutApm::Agent.instance.start_background_worker
+      @started = ScoutApm::Agent.instance.started? && ScoutApm::Agent.instance.background_worker_running?
     rescue => e
-      ScoutApm::Agent.instance.context.logger.info("Failed to start via Middleware: #{e.message}\n\t#{e.backtrace.join("\n\t")}")
+      # Can't be sure of any logging here, so fall back to ENV var and STDOUT
+      if ENV["SCOUT_LOG_LEVEL"] == "debug"
+        STDOUT.puts "Failed to start via Middleware: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      end
     end
   end
 end

data/lib/scout_apm/reporter.rb

@@ -2,60 +2,46 @@ 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 :config
+    attr_reader :logger
     attr_reader :type
-    attr_reader :context
     attr_reader :instant_key
 
-    def initialize(context, type, instant_key=nil)
-      @context = context
+    def initialize(type = :checkin, config=Agent.instance.config, logger=Agent.instance.logger, instant_key=nil)
+      @config = config
+      @logger = logger
       @type = type
       @instant_key = instant_key
     end
 
-    def config
-      context.config
-    end
-
-    def logger
-      context.logger
-    end
-
-    # The fully serialized string payload to be sent
+    # TODO: Parse & return a real response object, not the HTTP Response object
     def report(payload, headers = {})
-      hosts = determine_hosts
+      # Some posts (typically ones under development) bypass the ingestion pipeline and go directly to the webserver. They use direct_host instead of host
+      hosts = [:deploy_hook, :instant_trace].include?(type) ? config.value('direct_host') : config.value('host')
 
-      if config.value('compress_payload')
-        original_payload_size = payload.length
-
-        payload, compression_headers = compress_payload(payload)
-        headers.merge!(compression_headers)
-
-        compress_payload_size = payload.length
-        logger.debug("Original Size: #{original_payload_size} Compressed Size: #{compress_payload_size}")
+      Array(hosts).each do |host|
+        full_uri = uri(host)
+        response = post(full_uri, payload, headers)
+        unless response && response.is_a?(Net::HTTPSuccess)
+          logger.warn "Error on checkin to #{full_uri.to_s}: #{response.inspect}"
+        end
       end
-
-      logger.info("Posting payload to #{hosts.inspect}")
-      post_payload(hosts, payload, headers)
     end
 
     def uri(host)
-      encoded_app_name = CGI.escape(context.environment.application_name)
-      key = config.value('key')
-
       case type
       when :checkin
-        URI.parse("#{host}/apps/checkin.scout?key=#{key}&name=#{encoded_app_name}")
+        URI.parse("#{host}/apps/checkin.scout?key=#{config.value('key')}&name=#{CGI.escape(Environment.instance.application_name)}")
       when :app_server_load
-        URI.parse("#{host}/apps/app_server_load.scout?key=#{key}&name=#{encoded_app_name}")
+        URI.parse("#{host}/apps/app_server_load.scout?key=#{config.value('key')}&name=#{CGI.escape(Environment.instance.application_name)}")
       when :deploy_hook
-        URI.parse("#{host}/apps/deploy.scout?key=#{key}&name=#{encoded_app_name}")
+        URI.parse("#{host}/apps/deploy.scout?key=#{config.value('key')}&name=#{CGI.escape(config.value('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}") }
+        URI.parse("#{host}/apps/instant_trace.scout?key=#{config.value('key')}&name=#{CGI.escape(config.value('name'))}&instant_key=#{instant_key}")
+      end.tap{|u| logger.debug("Posting to #{u.to_s}")}
     end
 
     def can_report?
@@ -93,7 +79,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
@@ -109,7 +95,7 @@ module ScoutApm
 
     # Headers passed up with all API requests.
     def default_http_headers
-      { "Agent-Hostname" => context.environment.hostname,
+      { "Agent-Hostname" => ScoutApm::Environment.instance.hostname,
         "Content-Type"   => "application/octet-stream",
         "Agent-Version"  => ScoutApm::VERSION,
       }
@@ -120,46 +106,13 @@ module ScoutApm
     # Net::HTTP::Proxy returns a regular Net::HTTP class if the first argument (host) is nil.
     def http(url)
       proxy_uri = URI.parse(config.value('proxy').to_s)
-      http = Net::HTTP::Proxy(proxy_uri.host,
-                              proxy_uri.port,
-                              proxy_uri.user,
-                              proxy_uri.password).new(url.host, url.port)
+      http = Net::HTTP::Proxy(proxy_uri.host,proxy_uri.port,proxy_uri.user,proxy_uri.password).new(url.host, url.port)
       if url.is_a?(URI::HTTPS)
         http.use_ssl = true
-        http.ca_file = config.value("ssl_cert_file")
+        http.ca_file = CA_FILE
         http.verify_mode = VERIFY_MODE
       end
       http
     end
-
-    def compress_payload(payload)
-      [
-        ScoutApm::Utils::GzipHelper.new.deflate(payload),
-        { 'Content-Encoding' => 'gzip' }
-      ]
-    end
-
-    # Some posts (typically ones under development) bypass the ingestion
-    # pipeline and go directly to the webserver. They use direct_host instead
-    # of host
-    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
-    end
-
-    def post_payload(hosts, payload, headers)
-      Array(hosts).each do |host|
-        full_uri = uri(host)
-        response = post(full_uri, payload, headers)
-        unless response && response.is_a?(Net::HTTPSuccess)
-          logger.warn "Error on checkin to #{full_uri}: #{response.inspect}"
-        end
-      end
-    end
   end
 end

data/lib/scout_apm/request_histograms.rb

@@ -22,14 +22,6 @@ 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
@@ -47,10 +39,6 @@ module ScoutApm
       initialize_histograms_hash
     end
 
-    def raw(item)
-      @histograms[item]
-    end
-
     def initialize_histograms_hash
       @histograms = Hash.new { |h, k| h[k] = NumericHistogram.new(histogram_size) }
     end

data/lib/scout_apm/request_manager.rb

@@ -11,7 +11,7 @@ module ScoutApm
     def self.find
       req = Thread.current[:scout_request]
 
-      if req && (req.stopping? || req.recorded?)
+      if req && req.recorded?
         nil
       else
         req
@@ -19,11 +19,13 @@ module ScoutApm
     end
 
     # Create a new TrackedRequest object for this thread
-    # XXX: Figure out who is in charge of creating a `FakeStore` - previously was here
     def self.create
-      agent_context = ScoutApm::Agent.instance.context
-      store = agent_context.store
-      Thread.current[:scout_request] = TrackedRequest.new(agent_context, store)
+      store = if ScoutApm::Agent.instance.apm_enabled?
+                ScoutApm::Agent.instance.store
+              else
+                ScoutApm::FakeStore.new
+              end
+      Thread.current[:scout_request] = TrackedRequest.new(store)
     end
   end
 end

data/lib/scout_apm/scored_item_set.rb

@@ -63,12 +63,6 @@ module ScoutApm
       end
     end
 
-    # Equal to another set only if exactly the same set of items is inside
-    def eql?(other)
-      items == other.items
-    end
-
-    alias :== :eql?
 
     private
 
@@ -81,6 +75,5 @@ module ScoutApm
         items[new_item.name] = [new_item.score, new_item.call]
       end
     end
-
   end
 end

data/lib/scout_apm/serializers/app_server_load_serializer.rb

@@ -5,10 +5,6 @@ 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/deploy_serializer.rb

@@ -0,0 +1,16 @@
+# Serialize & deserialize deploy data up to the APM server
+module ScoutApm
+  module Serializers
+    class DeploySerializer
+      HTTP_HEADERS = {'Content-Type' => 'application/x-www-form-urlencoded'}
+
+      def self.serialize(data)
+        URI.encode_www_form(data)
+      end
+
+      def self.deserialize(data)
+        Marshal.load(data)
+      end
+    end
+  end
+end

data/lib/scout_apm/serializers/directive_serializer.rb

@@ -5,10 +5,6 @@ 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, 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, traces)
+      def self.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs)
+        if ScoutApm::Agent.instance.config.value("report_format") == 'json'
+          ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs)
         else
           metadata = metadata.dup
           metadata.default = nil
@@ -15,14 +15,7 @@ module ScoutApm
                        :metrics           => metrics,
                        :slow_transactions => slow_transactions,
                        :jobs              => jobs,
-                       :slow_jobs         => slow_jobs,
-
-                       # as_json returns a ruby object. Since it's not a simple
-                       # array, use this to maintain compatibility with json
-                       # payloads. At this point, the marshal code branch is
-                       # very rarely used anyway.
-                       :histograms        => HistogramsSerializerToJson.new(histograms).as_json,
-                       :db_query_metrics  => db_query_metrics)
+                       :slow_jobs         => slow_jobs)
         end
       end