scout_apm 3.0.0.pre11 → 3.0.0.pre12

data/lib/scout_apm/tracked_request.rb

@@ -290,47 +290,35 @@ module ScoutApm
       # Bail out early if the user asked us to ignore this uri
       return if ScoutApm::Agent.instance.ignored_uris.ignore?(annotations[:uri])
 
-      # Update immediate and long-term histograms for both job and web requests
-      if unique_name != :unknown
-        ScoutApm::Agent.instance.request_histograms.add(unique_name, root_layer.total_call_time)
-        ScoutApm::Agent.instance.request_histograms_by_time[@store.current_timestamp].
-          add(unique_name, root_layer.total_call_time)
+      converters = [
+        LayerConverters::Histograms,
+        LayerConverters::MetricConverter,
+        LayerConverters::ErrorConverter,
+        LayerConverters::AllocationMetricConverter,
+        LayerConverters::RequestQueueTimeConverter,
+        LayerConverters::JobConverter,
+        LayerConverters::DatabaseConverter,
+
+        LayerConverters::SlowJobConverter,
+        LayerConverters::SlowRequestConverter,
+      ]
+
+      layer_finder = LayerConverters::FindLayerByType.new(self)
+      walker = LayerConverters::DepthFirstWalker.new(self.root_layer)
+      converters = converters.map do |klass|
+        instance = klass.new(self, layer_finder, @store)
+        instance.register_hooks(walker)
+        instance
       end
-
-      metrics = LayerConverters::MetricConverter.new(self).call
-      @store.track!(metrics)
-
-      error_metrics = LayerConverters::ErrorConverter.new(self).call
-      @store.track!(error_metrics)
-
-      allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
-      @store.track!(allocation_metrics)
-
-      if web?
-        # Don't #call this - that's the job of the ScoredItemSet later.
-        slow_converter = LayerConverters::SlowRequestConverter.new(self)
-        @store.track_slow_transaction!(slow_converter)
-
-        queue_time_metrics = LayerConverters::RequestQueueTimeConverter.new(self).call
-        @store.track!(queue_time_metrics)
-
-        # If there's an instant_key, it means we need to report this right away
-        if instant?
-          trace = slow_converter.call
-          ScoutApm::InstantReporting.new(trace, instant_key).call
-        end
+      walker.walk
+      converters.each {|i| i.record! }
+
+      # If there's an instant_key, it means we need to report this right away
+      if web? && instant?
+        converter = converters.find{|c| c.class == LayerConverters::SlowRequestConverter}
+        trace = converter.call
+        ScoutApm::InstantReporting.new(trace, instant_key).call
       end
-
-      if job?
-        job_metrics = LayerConverters::JobConverter.new(self).call
-        @store.track_job!(job_metrics)
-
-        job_converter = LayerConverters::SlowJobConverter.new(self)
-        @store.track_slow_job!(job_converter)
-      end
-
-      allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
-      @store.track!(allocation_metrics)
     end
 
     # Only call this after the request is complete
@@ -338,7 +326,7 @@ module ScoutApm
       return nil if ignoring_request?
 
       @unique_name ||= begin
-                         scope_layer = LayerConverters::ConverterBase.new(self).scope_layer
+                         scope_layer = LayerConverters::FindLayerByType.new(self).scope
                          if scope_layer
                            scope_layer.legacy_metric_name
                          else

data/lib/scout_apm/utils/active_record_metric_name.rb

@@ -27,6 +27,14 @@ module ScoutApm
         end
       end
 
+      def model
+        parts.first
+      end
+
+      def normalized_operation
+        parse_operation
+      end
+
       # For the layer lookup.
       def hash
         h = name.downcase.hash
@@ -44,10 +52,6 @@ module ScoutApm
 
       private
 
-      def model
-        parts.first
-      end
-
       def operation
         if parts.length >= 2
           parts[1].downcase

data/lib/scout_apm/version.rb

@@ -1,3 +1,3 @@
 module ScoutApm
-  VERSION = "3.0.0.pre11"
+  VERSION = "3.0.0.pre12"
 end

data/test/unit/db_query_metric_set_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+require 'scout_apm/db_query_metric_set'
+
+module ScoutApm
+class DbQueryMetricSetTest < Minitest::Test
+  def test_hard_limit
+    config = make_fake_config(
+      'database_metric_limit' => 5, # The hard limit on db metrics
+      'database_metric_report_limit' => 2,)
+    set = DbQueryMetricSet.new(config)
+    set << fake_stat("a", 10)
+    set << fake_stat("b", 20)
+    set << fake_stat("c", 30)
+    set << fake_stat("d", 40)
+    set << fake_stat("e", 50)
+    set << fake_stat("f", 60)
+
+    assert_equal 5, set.metrics.size
+  end
+
+  def test_report_limit
+    config = make_fake_config(
+      'database_metric_limit' => 50, # much larger max, uninterested in hitting it.
+      'database_metric_report_limit' => 2,)
+    set = DbQueryMetricSet.new(config)
+    set << fake_stat("a", 10)
+    set << fake_stat("b", 20)
+    set << fake_stat("c", 30)
+    set << fake_stat("d", 40)
+    set << fake_stat("e", 50)
+    set << fake_stat("f", 60)
+
+    assert_equal 2, set.metrics_to_report.size
+    assert_equal ["f","e"], set.metrics_to_report.map{|m| m.key}
+  end
+
+  def test_combine
+    set1 = DbQueryMetricSet.new
+    set1 << fake_stat("a", 10)
+    set1 << fake_stat("b", 20)
+    set2 = DbQueryMetricSet.new
+    set2 << fake_stat("c", 10)
+    set2 << fake_stat("d", 20)
+
+    combined = set1.combine!(set2)
+    assert_equal ["a", "b", "c", "d"], combined.metrics.map{|_k, m| m.key}
+  end
+
+  def fake_stat(key, call_time)
+    OpenStruct.new(
+      key: key,
+      call_time: call_time)
+  end
+end
+end

data/test/unit/db_query_metric_stats_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+require 'scout_apm/db_query_metric_stats'
+
+module ScoutApm
+class DbQueryMetricStatsTest < Minitest::Test
+  def test_as_json_empty_stats
+    stat = build("table", "op", "Controller/public/index", 1, 10, 20)
+
+    assert_equal({
+      model_name: "table",
+      operation: "op",
+      call_count: 1,
+      transaction_count: 0,
+      scope: "Controller/public/index",
+      histogram: [[10.0, 1]],
+
+      max_call_time: 10.0,
+      min_call_time: 10.0,
+      call_time: 10.0,
+
+      max_rows_returned: 20,
+      min_rows_returned: 20,
+      rows_returned: 20,
+    }, stat.as_json)
+  end
+
+  def test_increment_transaction_count
+    stat = build()
+    assert_equal 0, stat.transaction_count
+
+    stat.increment_transaction_count!
+
+    assert_equal 1, stat.transaction_count
+  end
+
+  def test_key_name
+    stat = build("User", "find", "Controller/public/index")
+    assert_equal ["User", "find", "Controller/public/index"], stat.key
+  end
+
+  def test_combine_min_call_time_picks_smallest
+    stat1, stat2 = build_pair
+    assert_equal 5.1,  stat1.combine!(stat2).min_call_time
+  end
+
+  def test_combine_max_call_time_picks_largest
+    stat1, stat2 = build_pair
+    assert_equal 8.2,  stat1.combine!(stat2).max_call_time
+  end
+
+  def test_combine_call_counts_adds
+    stat1, stat2 = build_pair
+    assert_equal 5, stat1.combine!(stat2).call_count
+  end
+
+  def test_combine_transaction_count_adds
+    stat1, stat2 = build_pair
+    2.times { stat1.increment_transaction_count! }
+    3.times { stat2.increment_transaction_count! }
+
+    assert_equal 5, stat1.combine!(stat2).call_count
+  end
+
+  def test_combine_doesnt_merge_with_self
+    stat = build
+    merged = stat.combine!(stat)
+
+    assert_equal DEFAULTS[:call_count], merged.call_count
+    assert_equal DEFAULTS[:call_time], merged.call_time
+    assert_equal DEFAULTS[:rows_returned], merged.rows_returned
+  end
+
+  # A.combine!(B) should be the the same as B.combine!(A)
+  # Have to be a bit careful, since combine! is destructive, so make two pairs
+  # with same data to do both sides, then check that they result in the same
+  # answer
+  [:transaction_count, :call_count, :rows_returned, :min_rows_returned, :max_rows_returned, :max_call_time, :min_call_time].each do |attr|
+    define_method :"test_combine_#{attr}_is_symmetric" do
+      stat1_a, stat2_a = build_pair
+      stat1_b, stat2_b = build_pair
+      merged_a = stat1_a.combine!(stat2_a)
+      merged_b = stat2_b.combine!(stat1_b)
+
+      assert_equal merged_a.send(attr), merged_b.send(attr)
+    end
+  end
+
+  #############
+  #  Helpers  #
+  #############
+  DEFAULTS = {
+    call_count: 1,
+    call_time: 10.0,
+    rows_returned: 20,
+  }
+
+  def build(model_name="User",
+            operation="find",
+            scope="Controller/public/index",
+            call_count=DEFAULTS[:call_count],
+            call_time=DEFAULTS[:call_time],
+            rows_returned=DEFAULTS[:rows_returned])
+    DbQueryMetricStats.new(model_name, operation, scope, call_count, call_time, rows_returned)
+  end
+
+  def build_pair
+    stat1 = build("table", "op", "Controller/public/index", 2, 5.1, 10)
+    stat2 = build("table", "op", "Controller/public/index", 3, 8.2, 20)
+    [stat1, stat2]
+  end
+end
+end

data/test/unit/fake_store_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class FakeStoreTest < Minitest::Test
+  def test_responds_to_same_instance_methods_as_store
+    fs = ScoutApm::FakeStore.new
+    s = ScoutApm::Store.new
+
+    assert_equal [], s.methods - fs.methods
+  end
+end

data/test/unit/layer_converters/depth_first_walker_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module ScoutApm
+class DepthFirstWalkerTest < Minitest::Test
+  def test_walk_single_node_calls_callbacks_in_order
+    calls = []
+    layer = Layer.new("A", "x")
+
+    walker = LayerConverters::DepthFirstWalker.new(layer)
+    walker.before { |l| calls << :before }
+    walker.after { |l| calls << :after }
+    walker.on { |l| calls << :on }
+
+    walker.walk
+
+    assert_equal [:before, :on, :after], calls
+  end
+
+  # Tree looks like:
+  #    A
+  #    |
+  #    B
+  #  / \ \
+  #  C  D E
+  # / \
+  # F  G
+  def test_walk_interesting_tree
+    calls = []
+    a = Layer.new("A", "x")
+    b = Layer.new("B", "x")
+    c = Layer.new("C", "x")
+    d = Layer.new("D", "x")
+    e = Layer.new("E", "x")
+    f = Layer.new("F", "x")
+    g = Layer.new("G", "x")
+    a.add_child(b)
+    b.add_child(c)
+    b.add_child(d)
+    b.add_child(e)
+    c.add_child(f)
+    c.add_child(g)
+
+    root_layer = a
+
+    walker = LayerConverters::DepthFirstWalker.new(root_layer)
+    walker.before { |l| calls << "#{l.type} before" }
+    walker.after { |l| calls << "#{l.type} after" }
+    walker.on { |l| calls << "#{l.type} on" }
+
+    walker.walk
+
+    assert_equal [
+      "A before", "A on", # before & on always line up next to each other
+      "B before", "B on",
+      "C before", "C on",
+      "F before", "F on", "F after", # leaf nodes run all 3
+      "G before", "G on", "G after",
+      "C after", # once all children are done, do a node's after
+      "D before", "D on", "D after",
+      "E before", "E on", "E after",
+      "B after",
+      "A after"
+    ], calls
+  end
+end
+end

data/test/unit/layer_converters/metric_converter_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+require_relative 'stubs'
+
+module ScoutApm
+module LayerConverters
+class MetricConverterTest < Minitest::Test
+  include Stubs
+
+  def test_register_adds_hooks
+    mc = MetricConverter.new(faux_request, faux_layer_finder, faux_store)
+    faux_walker.expects(:on)
+    mc.register_hooks(faux_walker)
+  end
+
+  def test_record
+    mc = MetricConverter.new(faux_request, faux_layer_finder, faux_store)
+    faux_store.expects(:track!)
+    mc.record!
+  end
+end
+end
+end

data/test/unit/layer_converters/stubs.rb

@@ -0,0 +1,33 @@
+####################################
+#  Stubs for LayerConverter Tests  #
+####################################
+module ScoutApm
+  module LayerConverters
+    module Stubs
+      def faux_walker(subscope_stubs: true)
+        @w ||= stub
+
+        if subscope_stubs && !@w_set_subscope_stubs
+          @w_set_subscope_stubs = true
+          @w.expects(:before)
+          @w.expects(:after)
+        end
+        @w
+      end
+
+      def faux_request
+        @req ||= stub(:root_layer => stub)
+      end
+
+      def faux_layer_finder
+        @layer_finder ||= stub
+        @layer_finder.stubs(scope: stub)
+        @layer_finder
+      end
+
+      def faux_store
+        @store ||= stub
+      end
+    end
+  end
+end

data/test/unit/serializers/payload_serializer_test.rb

@@ -1,13 +1,4 @@
 require 'test_helper'
-require 'scout_apm/attribute_arranger'
-require 'scout_apm/bucket_name_splitter'
-require 'scout_apm/serializers/payload_serializer'
-require 'scout_apm/serializers/payload_serializer_to_json'
-require 'scout_apm/slow_transaction'
-require 'scout_apm/metric_meta'
-require 'scout_apm/metric_stats'
-require 'scout_apm/context'
-require 'ostruct'
 require 'json' # to deserialize what has been manually serialized by the production code
 
 class PayloadSerializerTest < Minitest::Test
@@ -17,7 +8,7 @@ class PayloadSerializerTest < Minitest::Test
       :unique_id => "unique_idz",
       :agent_version => 123
     }
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {}, [], [], [])
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {}, [], [], [], {})
 
     # symbol keys turn to strings
     formatted_metadata = {
@@ -58,7 +49,7 @@ class PayloadSerializerTest < Minitest::Test
         stats.total_exclusive_time = 0.07813208899999999
       }
     }
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, metrics, {}, [], [], [])
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, metrics, {}, [], [], [], {})
     formatted_metrics = [
       {
         "key" => {
@@ -104,7 +95,7 @@ class PayloadSerializerTest < Minitest::Test
       :quotie => "here are some \"quotes\"",
       :payload_version => 2,
     }
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {}, [], [], [])
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize(metadata, {}, {}, [], [], [], {})
 
     # symbol keys turn to strings
     formatted_metadata = {