scout_apm 3.0.0.pre11 → 3.0.0.pre12

data/lib/scout_apm/layer.rb

@@ -80,6 +80,10 @@ module ScoutApm
       @trace_index = ScoutApm::Instruments::Stacks.current_trace_index
     end
 
+    def limited?
+      false
+    end
+
     def add_child(child)
       @children ||= LayerChildrenSet.new
       @children << child

data/lib/scout_apm/layer_converters/allocation_metric_converter.rb

@@ -1,16 +1,15 @@
 module ScoutApm
   module LayerConverters
     class AllocationMetricConverter < ConverterBase
-      def call
-        scope = scope_layer
-        return {} unless scope
-        return {} unless ScoutApm::Instruments::Allocations::ENABLED
+      def record!
+        return unless scope_layer
+        return unless ScoutApm::Instruments::Allocations::ENABLED
 
-        meta = MetricMeta.new("ObjectAllocations", {:scope => scope.legacy_metric_name})
+        meta = MetricMeta.new("ObjectAllocations", {:scope => scope_layer.legacy_metric_name})
         stat = MetricStats.new
         stat.update!(root_layer.total_allocations)
 
-        { meta => stat }
+        @store.track!({ meta => stat })
       end
     end
   end

data/lib/scout_apm/layer_converters/converter_base.rb

@@ -2,34 +2,22 @@ module ScoutApm
   module LayerConverters
     class ConverterBase
 
-      attr_reader :walker
       attr_reader :request
       attr_reader :root_layer
+      attr_reader :layer_finder
 
-      def initialize(request)
+      def initialize(request, layer_finder, store=nil)
         @request = request
+        @layer_finder = layer_finder
+        @store = store
+
         @root_layer = request.root_layer
         @backtraces = []
-        @walker = DepthFirstWalker.new(root_layer)
-
         @limited = false
       end
 
-      # Scope is determined by the first Controller we hit.  Most of the time
-      # there will only be 1 anyway.  But if you have a controller that calls
-      # another controller method, we may pick that up:
-      #     def update
-      #       show
-      #       render :update
-      #     end
       def scope_layer
-        @scope_layer ||= find_first_layer_of_type("Controller") || find_first_layer_of_type("Job")
-      end
-
-      def find_first_layer_of_type(layer_type)
-        walker.walk do |layer|
-          return layer if layer.type == layer_type
-        end
+        layer_finder.scope
       end
 
       ################################################################################
@@ -39,7 +27,7 @@ module ScoutApm
       # 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.
-      def setup_subscopable_callbacks
+      def register_hooks(walker)
         @subscope_layers = []
 
         walker.before do |layer|

data/lib/scout_apm/layer_converters/database_converter.rb

@@ -0,0 +1,81 @@
+module ScoutApm
+  module LayerConverters
+    class DatabaseConverter < ConverterBase
+      def initialize(*)
+        super
+        @db_query_metric_set = DbQueryMetricSet.new
+      end
+
+      def register_hooks(walker)
+        super
+
+        return unless scope_layer
+
+        walker.on do |layer|
+          next if skip_layer?(layer)
+
+          stat = DbQueryMetricStats.new(
+            model_name(layer),
+            operation_name(layer),
+            scope_layer.legacy_metric_name, # controller_scope
+            1,                              # count, this is a single query, so 1
+            layer.total_call_time,
+            records_returned(layer)
+          )
+          @db_query_metric_set << stat
+        end
+      end
+
+      def record!
+        # Everything in the metric set here is from a single transaction, which
+        # we want to keep track of. (One web call did a User#find 10 times, but
+        # only due to 1 http request)
+        @db_query_metric_set.increment_transaction_count!
+        @store.track_db_query_metrics!(@db_query_metric_set)
+      end
+
+      def skip_layer?(layer)
+        layer.type != 'ActiveRecord' ||
+          layer.limited? ||
+          super
+      end
+
+      private
+
+
+      # If we can't name the model, default to:
+      DEFAULT_MODEL = "SQL"
+
+      # If we can't name the operation, default to:
+      DEFAULT_OPERATION = "other"
+
+      def model_name(layer)
+        if layer.name.respond_to?(:model)
+          layer.name.model || DEFAULT_MODEL
+        else
+          DEFAULT_MODEL
+        end
+      rescue
+        DEFAULT_MODEL
+      end
+
+      def operation_name(layer)
+        if layer.name.respond_to?(:normalized_operation)
+          layer.name.normalized_operation || DEFAULT_OPERATION
+        else
+          DEFAULT_OPERATION
+        end
+      rescue
+        DEFAULT_OPERATION
+      end
+
+      def records_returned(layer)
+        if layer.annotations
+          layer.annotations.fetch(:record_count, 0)
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/layer_converters/depth_first_walker.rb

@@ -5,30 +5,42 @@ module ScoutApm
 
       def initialize(root_layer)
         @root_layer = root_layer
+
+        @on_blocks = []
+        @before_blocks = []
+        @after_blocks = []
       end
 
       def before(&block)
-        @before_block = block
+        @before_blocks << block
       end
 
       def after(&block)
-        @after_block = block
+        @after_blocks << block
+      end
+
+      def on(&block)
+        @on_blocks << block
       end
 
-      def walk(layer=root_layer, &block)
+      def walk(layer=root_layer)
         # Need to run this for the root layer the first time through.
         if layer == root_layer
-          @before_block.call(layer) if @before_block
-          yield layer
-          @after_block.call(layer) if @after_block
+          @before_blocks.each{|b| b.call(layer) }
+          @on_blocks.each{|b| b.call(layer) }
         end
 
         layer.children.each do |child|
-          @before_block.call(child) if @before_block
-          yield child
-          walk(child, &block)
-          @after_block.call(child) if @after_block
+          @before_blocks.each{|b| b.call(child) }
+          @on_blocks.each{|b| b.call(child) }
+          walk(child)
+          @after_blocks.each{|b| b.call(child) }
         end
+
+        if layer == root_layer
+          @after_blocks.each{|b| b.call(layer) }
+        end
+
         nil
       end
     end

data/lib/scout_apm/layer_converters/error_converter.rb

@@ -1,19 +1,17 @@
 module ScoutApm
   module LayerConverters
     class ErrorConverter < ConverterBase
-      def call
-        scope = scope_layer
-
+      def record!
         # Should we mark a request as errored out if a middleware raises?
         # How does that interact w/ a tool like Sentry or Honeybadger?
-        return {} unless scope
-        return {} unless request.error?
+        return unless scope_layer
+        return unless request.error?
 
-        meta = MetricMeta.new("Errors/#{scope.legacy_metric_name}", {})
+        meta = MetricMeta.new("Errors/#{scope_layer.legacy_metric_name}", {})
         stat = MetricStats.new
         stat.update!(1)
 
-        { meta => stat }
+        @store.track!({ meta => stat })
       end
     end
   end

data/lib/scout_apm/layer_converters/find_layer_by_type.rb

@@ -0,0 +1,34 @@
+# Scope is determined by the first Controller we hit.  Most of the time
+# there will only be 1 anyway.  But if you have a controller that calls
+# another controller method, we may pick that up:
+#     def update
+#       show
+#       render :update
+#     end
+module ScoutApm
+  module LayerConverters
+    class FindLayerByType
+      def initialize(request)
+        @request = request
+      end
+
+      def scope
+        @scope ||= call(["Controller", "Job"])
+      end
+
+      def job
+        @job ||= call(["Job"])
+      end
+
+      def queue
+        @queue ||= call(["Queue"])
+      end
+
+      def call(layer_types)
+        walker = DepthFirstWalker.new(@request.root_layer)
+        walker.on {|l| return l if layer_types.include?(l.type) }
+        walker.walk
+      end
+    end
+  end
+end

data/lib/scout_apm/layer_converters/histograms.rb

@@ -0,0 +1,14 @@
+module ScoutApm
+  module LayerConverters
+    class Histograms < ConverterBase
+      # Updates immediate and long-term histograms for both job and web requests
+      def record!
+        if request.unique_name != :unknown
+          ScoutApm::Agent.instance.request_histograms.add(request.unique_name, root_layer.total_call_time)
+          ScoutApm::Agent.instance.request_histograms_by_time[@store.current_timestamp].
+            add(request.unique_name, root_layer.total_call_time)
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/layer_converters/job_converter.rb

@@ -10,53 +10,19 @@
 module ScoutApm
   module LayerConverters
     class JobConverter < ConverterBase
-      def call
-        return unless request.job?
-
-        JobRecord.new(
-          queue_layer.name,
-          job_layer.name,
-          job_layer.total_call_time,
-          job_layer.total_exclusive_time,
-          errors,
-          create_metrics
-        )
-      end
-
-      def queue_layer
-        @queue_layer ||= find_first_layer_of_type("Queue")
-      end
+      attr_reader :meta_options
 
-      def job_layer
-        @job_layer ||= find_first_layer_of_type("Job")
-      end
-
-      def errors
-        if request.error?
-          1
-        else
-          0
-        end
-      end
-
-      def find_first_layer_of_type(layer_type)
-        walker.walk do |layer|
-          return layer if layer.type == layer_type
-        end
-      end
+      def register_hooks(walker)
+        return unless request.job?
 
-      # Full metrics from this request. These get aggregated in Store for the
-      # overview metrics, or 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.
-      def create_metrics
-        metric_hash = Hash.new
+        super
 
-        meta_options = {:scope => job_layer.legacy_metric_name}
+        @metrics = Hash.new
+        @meta_options = {:scope => layer_finder.job.legacy_metric_name}
 
-        walker.walk do |layer|
-          next if layer == job_layer
-          next if layer == queue_layer
+        walker.on do |layer|
+          next if layer == layer_finder.job
+          next if layer == layer_finder.queue
           next if skip_layer?(layer)
 
           # we don't need to use the full metric name for scoped metrics as we
@@ -65,20 +31,40 @@ module ScoutApm
           metric_name = layer.type
 
           meta = MetricMeta.new(metric_name, meta_options)
-          metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
+          @metrics[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
 
-          stat = metric_hash[meta]
+          stat = @metrics[meta]
           stat.update!(layer.total_call_time, layer.total_exclusive_time)
         end
 
-        # Add the latency metric, which wasn't stored as a distinct layer
+      end
+
+      def record!
+        return unless request.job?
+
+        errors = request.error? ? 1 : 0
+        add_latency_metric!
+
+        record = JobRecord.new(
+          layer_finder.queue.name,
+          layer_finder.job.name,
+          layer_finder.job.total_call_time,
+          layer_finder.job.total_exclusive_time,
+          errors,
+          @metrics
+        )
+
+        @store.track_job!(record)
+      end
+
+      # This isn't stored as a specific layer, so grabbing it doesn't use the
+      # walker callbacks
+      def add_latency_metric!
         latency = request.annotations[:queue_latency] || 0
         meta = MetricMeta.new("Latency", meta_options)
         stat = MetricStats.new
         stat.update!(latency)
-        metric_hash[meta] = stat
-
-        metric_hash
+        @metrics[meta] = stat
       end
     end
   end

data/lib/scout_apm/layer_converters/metric_converter.rb

@@ -1,26 +1,21 @@
 # Take a TrackedRequest and turn it into a hash of:
 #   MetricMeta => MetricStats
+
+# Full metrics from this request. These get aggregated in Store for the
+# overview metrics, or 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.
 module ScoutApm
   module LayerConverters
     class MetricConverter < ConverterBase
-      def call
-        scope = scope_layer
-
-        # TODO: Track requests that never reach a Controller (for example, when
-        # Middleware decides to return rather than passing onward)
-        return {} unless scope
+      def register_hooks(walker)
+        super
 
-        create_metrics
-      end
+        @metrics = {}
 
-      # Full metrics from this request. These get aggregated in Store for the
-      # overview metrics, or 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.
-      def create_metrics
-        metric_hash = Hash.new
+        return unless scope_layer
 
-        walker.walk do |layer|
+        walker.on do |layer|
           next if skip_layer?(layer)
 
           meta_options = if layer == scope_layer # We don't scope the controller under itself
@@ -34,12 +29,15 @@ module ScoutApm
           metric_name = meta_options.has_key?(:scope) ? layer.type : layer.legacy_metric_name
 
           meta = MetricMeta.new(metric_name, meta_options)
-          metric_hash[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
+          @metrics[meta] ||= MetricStats.new( meta_options.has_key?(:scope) )
 
-          stat = metric_hash[meta]
+          stat = @metrics[meta]
           stat.update!(layer.total_call_time, layer.total_exclusive_time)
         end
-        metric_hash
+      end
+
+      def record!
+        @store.track!(@metrics)
       end
     end
   end