scout_apm 2.1.32 → 2.2.0.pre0

data/test/unit/config_test.rb

@@ -4,78 +4,27 @@ require 'scout_apm/config'
 
 class ConfigTest < Minitest::Test
   def test_initalize_without_a_config
-    conf = ScoutApm::Config.without_file
+    conf = ScoutApm::Config.new(nil)
 
     # nil for random keys
-    assert_nil conf.value('log_file_path')
+    assert_nil conf.value("log_file_path")
 
     # but has values for defaulted keys
-    assert conf.value('host')
+    assert conf.value("host")
 
     # and still reads from ENV
     ENV['SCOUT_CONFIG_TEST_KEY'] = 'testval'
-    assert_equal 'testval', conf.value('config_test_key')
+    assert_equal 'testval', conf.value("config_test_key")
   end
 
   def test_loading_a_file
-    set_rack_env('production')
+    set_rack_env("production")
 
-    conf_file = File.expand_path('../../data/config_test_1.yml', __FILE__)
-    conf = ScoutApm::Config.with_file(conf_file)
-
-    assert_equal 'debug', conf.value('log_level')
-    assert_equal 'APM Test Conf (Production)', conf.value('name')
-  end
-
-  def test_loading_file_without_env_in_file
     conf_file = File.expand_path("../../data/config_test_1.yml", __FILE__)
-    conf = ScoutApm::Config.with_file(conf_file, environment: "staging")
+    conf = ScoutApm::Config.new(conf_file)
 
-    assert_equal "info", conf.value('log_level') # the default value
-    assert_nil nil, conf.value('name')         # the default value
-  end
-
-  def test_boolean_coercion
-    coercion = ScoutApm::Config::BooleanCoercion.new
-    assert_equal true, coercion.coerce("true")
-    assert_equal true, coercion.coerce("t")
-    assert_equal false, coercion.coerce("false")
-    assert_equal false, coercion.coerce("f")
-    assert_equal false, coercion.coerce("")
-
-    assert_equal true, coercion.coerce(true)
-    assert_equal false, coercion.coerce(false)
-    assert_equal false, coercion.coerce(nil)
-
-    assert_equal true, coercion.coerce(1)
-    assert_equal true, coercion.coerce(20)
-    assert_equal true, coercion.coerce(-1)
-    assert_equal false, coercion.coerce(0)
-
-    # for any other unknown class, there is no clear answer, so be safe and say false.
-    assert_equal false, coercion.coerce([])
-  end
-
-  def test_json_coersion
-    coercion = ScoutApm::Config::JsonCoercion.new
-    assert_equal [1,2,3], coercion.coerce('[1,2,3]')
-    assert_equal ['foo/bar','baz/quux'], coercion.coerce('["foo/bar", "baz/quux"]')
-
-    assert_equal({"foo" => "bar"}, coercion.coerce('{"foo": "bar"}'))
-
-    assert_equal true, coercion.coerce(true)
-    assert_equal 10, coercion.coerce(10)
-    assert_equal ["a"], coercion.coerce(["a"])
-  end
-
-  def test_any_keys_found
-    ENV.stubs(:has_key?).returns(nil)
-
-    conf = ScoutApm::Config.with_file("a_file_that_doesnt_exist.yml")
-    assert ! conf.any_keys_found?
-
-    ENV.stubs(:has_key?).with("SCOUT_MONITOR").returns("true")
-    conf = ScoutApm::Config.with_file("a_file_that_doesnt_exist.yml")
-    assert conf.any_keys_found?
+    assert_equal "debug", conf.value('log_level')
+    assert_equal "APM Test Conf (Production)", conf.value('name')
   end
 end
+

data/test/unit/histogram_test.rb

@@ -79,20 +79,6 @@ class HistogramTest < Minitest::Test
     assert combined.quantile(0) < combined.quantile(100)
   end
 
-  def test_combine_dedups_identicals
-    hist1 = ScoutApm::NumericHistogram.new(5)
-    hist2 = ScoutApm::NumericHistogram.new(5)
-    hist1.add(1)
-    hist1.add(2)
-    hist2.add(2)
-    hist2.add(3)
-
-    combined = hist1.combine!(hist2)
-    assert_equal 4, combined.total
-    assert_equal [[1, 1], [2, 2], [1, 3]],
-      combined.bins.map{|bin| [bin.count, bin.value.to_i] }
-  end
-
   def test_mean
     hist = ScoutApm::NumericHistogram.new(5)
     10.times {

data/test/unit/layaway_test.rb

@@ -5,40 +5,25 @@ require 'scout_apm/metric_stats'
 require 'scout_apm/context'
 require 'scout_apm/store'
 
-require 'fileutils'
 class LayawayTest < Minitest::Test
-  def test_directory_uses_DATA_FILE_option
-    FileUtils.mkdir_p '/tmp/scout_apm_test/data_file_option'
-    config = make_fake_config("data_file" => "/tmp/scout_apm_test/data_file_option")
-
-    assert_equal Pathname.new("/tmp/scout_apm_test/data_file_option"), ScoutApm::Layaway.new(config, ScoutApm::Agent.instance.environment).directory
+  def test_add_reporting_period
+    File.open(DATA_FILE_PATH, 'w') { |file| file.write(Marshal.dump(NEW_FORMAT)) }
+    ScoutApm::Agent.instance.start
+
+    data = ScoutApm::Layaway.new
+    t = ScoutApm::StoreReportingPeriodTimestamp.new
+    data.add_reporting_period(t,ScoutApm::StoreReportingPeriod.new(t))
+    assert_equal [TIMESTAMP,t].sort_by(&:timestamp), Marshal.load(File.read(DATA_FILE_PATH)).keys.sort_by(&:timestamp)
   end
 
-  def test_directory_looks_for_root_slash_tmp
-    FileUtils.mkdir_p '/tmp/scout_apm_test/tmp'
-    config = make_fake_config({})
-    env = make_fake_environment(:root => "/tmp/scout_apm_test")
-
-    assert_equal Pathname.new("/tmp/scout_apm_test/tmp"), ScoutApm::Layaway.new(config, env).directory
+  def test_merge_reporting_period
+    File.open(DATA_FILE_PATH, 'w') { |file| file.write(Marshal.dump(NEW_FORMAT)) }
+    layaway = ScoutApm::Layaway.new
+    layaway.add_reporting_period(TIMESTAMP, ScoutApm::StoreReportingPeriod.new(TIMESTAMP))
+    unmarshalled = Marshal.load(File.read(DATA_FILE_PATH))
+    assert_equal [TIMESTAMP], unmarshalled.keys
   end
 
-  def test_layaway_file_limit_prevents_new_writes
-    FileUtils.mkdir_p '/tmp/scout_apm_test/layaway_limit'
-    config = make_fake_config("data_file" => "/tmp/scout_apm_test/layaway_limit")
-    layaway = ScoutApm::Layaway.new(config, ScoutApm::Agent.instance.environment)
-    layaway.delete_files_for(:all)
-
-    current_time = Time.now.utc
-    current_rp = ScoutApm::StoreReportingPeriod.new(current_time)
-    stale_rp = ScoutApm::StoreReportingPeriod.new(current_time - current_time.sec - 120)
-
-    # layaway.write_reporting_period returns nil on successful write
-    # It should probably be changed to return true or the number of bytes written
-    assert_nil layaway.write_reporting_period(stale_rp, 1)
-
-    # layaway.write_reporting_period returns an explicit false class on failure
-    assert layaway.write_reporting_period(current_rp, 1).is_a?(FalseClass)
-
-    layaway.delete_files_for(:all)
-  end
+  TIMESTAMP = ScoutApm::StoreReportingPeriodTimestamp.new(Time.parse("2015-01-01"))
+  NEW_FORMAT = {TIMESTAMP => ScoutApm::StoreReportingPeriod.new(TIMESTAMP)} # Format for 1.2+ agents
 end

data/test/unit/serializers/payload_serializer_test.rb

@@ -6,18 +6,33 @@ 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/utils/fake_stack_prof'
 require 'scout_apm/context'
 require 'ostruct'
 require 'json' # to deserialize what has been manually serialized by the production code
 
+# stub the report_format value
+# class ScoutApm::Agent
+  # module Config
+    # def self.value(key)
+      # 'json'
+    # end
+  # end
+
+  # def self.instance
+    # OpenStruct.new(:config => Config)
+  # end
+# end
+
 class PayloadSerializerTest < Minitest::Test
+
   def test_serializes_metadata_as_json
     metadata = {
       :app_root => "/srv/app/rootz",
       :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 +73,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" => {
@@ -97,12 +112,99 @@ class PayloadSerializerTest < Minitest::Test
     assert_equal formatted_metrics, JSON.parse(payload)["metrics"]
   end
 
+  def test_serializes_slow_transactions_as_json
+    slow_transaction_metrics = {
+      ScoutApm::MetricMeta.new('ActiveRecord/all').tap { |meta|
+        meta.desc = "SELECT *\nfrom users where filter=?"
+        meta.extra = {:user => 'cooluser'}
+        meta.metric_id = nil
+        meta.scope = "Controller/apps/checkin"
+      } => ScoutApm::MetricStats.new.tap { |stats|
+        stats.call_count = 16
+        stats.max_call_time = 0.005338062
+        stats.min_call_time = 0.000613518
+        stats.sum_of_squares = 9.8040860751126e-05
+        stats.total_call_time = 0.033245704
+        stats.total_exclusive_time = 0.033245704
+      },
+      ScoutApm::MetricMeta.new("Controller/apps/checkin").tap { |meta|
+        meta.desc = nil
+        meta.extra = {}
+        meta.metric_id = nil
+        meta.scope = nil
+      } => ScoutApm::MetricStats.new.tap { |stats|
+        stats.call_count = 2
+        stats.max_call_time = 0.078521419
+        stats.min_call_time = 0.034881757
+        stats.sum_of_squares = 0.007382350213180609
+        stats.total_call_time = 0.113403176
+        stats.total_exclusive_time = 0.07813208899999999
+      }
+    }
+    context = ScoutApm::Context.new
+    context.add({"this" => "that"})
+    context.add_user({"hello" => "goodbye"})
+    slow_t = ScoutApm::SlowTransaction.new("http://example.com/blabla", "Buckethead/something/else", 1.23, slow_transaction_metrics, context, Time.at(1448198788), [], 10)
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, {}, [slow_t], [], [])
+    formatted_slow_transactions = [
+      {
+        "key" => {
+          "bucket" => "Buckethead",
+          "name" => "something/else"
+        },
+        "time" => "2015-11-22 06:26:28 -0700",
+        "total_call_time" => 1.23,
+        "uri" => "http://example.com/blabla",
+        "context" => {"this"=>"that", "user"=>{"hello"=>"goodbye"}},
+        "prof" => [],
+        "score" => 10,
+        "metrics" => [
+          {
+            "key" => {
+              "bucket" => "ActiveRecord",
+              "name" => "all",
+              "desc" => "SELECT *\nfrom users where filter=?",
+              "extra" => {
+                "user" => "cooluser",
+              },
+              "scope" => {
+                "bucket" => "Controller",
+                "name" => "apps/checkin",
+              },
+            },
+            "call_count" => 16,
+            "max_call_time" => 0.005338062,
+            "min_call_time" => 0.000613518,
+            "total_call_time" => 0.033245704,
+            "total_exclusive_time" => 0.033245704,
+          },
+          {
+            "key" => {
+              "bucket" => "Controller",
+              "name" => "apps/checkin",
+              "desc" => nil,
+              "extra" => {},
+              "scope" => nil,
+            },
+            "call_count" => 2,
+            "max_call_time" => 0.078521419,
+            "min_call_time" => 0.034881757,
+            "total_call_time" => 0.113403176,
+            "total_exclusive_time" => 0.07813208899999999,
+          }
+        ]
+      }
+    ]
+
+    assert_equal formatted_slow_transactions, JSON.parse(payload)["slow_transactions"]
+  end
+
   def test_escapes_json_quotes
     metadata = {
       :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 = {

data/test/unit/slow_item_set_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+require 'scout_apm/slow_item_set'
+require 'scout_apm/slow_transaction'
+
+class SlowItemSetTest < Minitest::Test
+  def test_adding_to_empty_set
+    set = ScoutApm::SlowItemSet.new(3, 1)
+    set << make_slow("Controller/Foo")
+    assert_equal 1, set.count
+  end
+
+  def test_adding_to_partially_full_set
+    set = ScoutApm::SlowItemSet.new(3, 1)
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    assert_equal 2, set.count
+  end
+
+  def test_overflow_of_one_type
+    max_size = 3
+    set = ScoutApm::SlowItemSet.new(max_size, 1)
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    assert_equal max_size, set.count
+  end
+
+  def test_eviction_of_overrepresented
+    max_size = 3
+    set = ScoutApm::SlowItemSet.new(max_size, 1)
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Bar")
+
+    # 3 total
+    assert_equal max_size, set.count
+    assert_equal 1, set.select{|sl| sl.metric_name == "Controller/Bar"}.length
+    assert_equal 2, set.select{|sl| sl.metric_name == "Controller/Foo"}.length
+  end
+
+  # Fill the set with /Foo records, then add a /Bar to evict. Check that the
+  # evicted one was the fastest of the Foos
+  def test_eviction_of_fastest
+    max_size = 3
+    set = ScoutApm::SlowItemSet.new(max_size, 1)
+
+    [1,2,3].shuffle.each do |seconds| # Shuffle to remove any assumptions on order
+      set << make_slow("Controller/Foo", seconds)
+    end
+    set << make_slow("Controller/Bar", 8)
+
+    # The foo taking 1 second should be evicted
+    assert_equal 2, set.select{|sl| sl.metric_name == "Controller/Foo"}.map{ |sl| sl.total_call_time}.min
+  end
+
+  def test_eviction_when_no_overrepresented
+    max_size = 4
+    fair = 2
+    set = ScoutApm::SlowItemSet.new(max_size, fair)
+
+    # Full, but each is at fair level
+    set << make_slow("Controller/Bar")
+    set << make_slow("Controller/Bar")
+    set << make_slow("Controller/Foo")
+    set << make_slow("Controller/Foo")
+
+    set << make_slow("Controller/Quux")
+    assert_equal max_size, set.count
+    assert_equal 0, set.select{|sl| sl.metric_name == "Controller/Quux" }.length
+  end
+
+  ##############
+  #### Helpers
+  ##############
+
+  def make_slow(metric, time=5)
+    ScoutApm::SlowTransaction.new(
+      "http://foo.app/#{metric}",
+      metric,
+      time,
+      {}, # metrics
+      {}, # context
+      Time.now, # end time
+      [], # stackprof
+      0)
+  end
+end

data/test/unit/slow_job_policy_test.rb

@@ -3,4 +3,53 @@ require 'test_helper'
 require 'scout_apm/slow_job_policy'
 
 class SlowJobPolicyTest < Minitest::Test
+  def test_first_call_is_not_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    assert !policy.slow?("TestWorker", 10)
+  end
+
+  # All of these get faster and faster, so none are marked as slow.
+  def test_fast_calls_are_not_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    assert !policy.slow?("TestWorker", 10)
+    assert !policy.slow?("TestWorker", 8)
+    assert !policy.slow?("TestWorker", 6)
+    assert !policy.slow?("TestWorker", 4)
+    assert !policy.slow?("TestWorker", 2)
+  end
+
+  def test_slow_calls_are_marked_as_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    policy.slow?("TestWorker", 10) # Prime it with a not-slow
+
+    assert policy.slow?("TestWorker", 12)
+    assert policy.slow?("TestWorker", 14)
+    assert policy.slow?("TestWorker", 16)
+    assert policy.slow?("TestWorker", 18)
+  end
+
+  def test_mix_of_fast_and_slow
+    policy = ScoutApm::SlowJobPolicy.new
+    policy.slow?("TestWorker", 10) # Prime it with a not-slow
+
+    assert  policy.slow?("TestWorker", 12)
+    assert !policy.slow?("TestWorker", 8)
+    assert  policy.slow?("TestWorker", 13)
+    assert !policy.slow?("TestWorker", 6)
+  end
+
+  def test_different_workers_dont_interfere
+    policy = ScoutApm::SlowJobPolicy.new
+    policy.slow?("TestWorker", 10) # Prime it with a not-slow
+    policy.slow?("OtherWorker", 1.0) # Prime it with a not-slow
+
+    assert !policy.slow?("TestWorker", 8)
+    assert  policy.slow?("OtherWorker", 2)
+    assert !policy.slow?("TestWorker", 1)
+    assert  policy.slow?("OtherWorker", 3)
+    assert  policy.slow?("TestWorker", 12)
+    assert !policy.slow?("OtherWorker", 1)
+    assert  policy.slow?("TestWorker", 12)
+    assert  policy.slow?("OtherWorker", 4)
+  end
 end