scout_apm 2.2.0.pre3 → 2.3.0.pre

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/utils/backtrace_parser.rb

@@ -6,8 +6,8 @@ require 'scout_apm/environment'
 module ScoutApm
   module Utils
     class BacktraceParser
-
-      APP_FRAMES = 3 # will return up to 3 frames from the app stack.
+      # will return this many backtrace frames from the app stack.
+      APP_FRAMES = 8
 
       attr_reader :call_stack
 
@@ -24,7 +24,7 @@ module ScoutApm
         stack = []
         call_stack.each do |c|
           if m = c.match(@@app_dir_regex)
-            stack << m[1]
+            stack << ScoutApm::Utils::Scm.relative_scm_path(m[1])
             break if stack.size == APP_FRAMES
           end
         end

data/lib/scout_apm/utils/gzip_helper.rb

@@ -0,0 +1,24 @@
+module ScoutApm
+  module Utils
+    # A simple wrapper around Ruby's built-in gzip support.
+    class GzipHelper
+      DEFAULT_GZIP_LEVEL = 5
+
+      attr_reader :level
+
+      def initialize(level = DEFAULT_GZIP_LEVEL)
+        @level = level
+      end
+
+      def deflate(str)
+        strio = StringIO.new
+
+        gz = Zlib::GzipWriter.new(strio, level)
+        gz.write str
+        gz.close
+
+        strio.string
+      end
+    end
+  end
+end

data/lib/scout_apm/utils/numbers.rb

@@ -0,0 +1,14 @@
+module ScoutApm
+  module Utils
+    class Numbers
+
+      # Round a float to a certain number of decimal places
+      def self.round(number, decimals)
+        factor = 10 ** decimals
+
+        (number * factor).round / factor.to_f
+      end
+
+    end
+  end
+end

data/lib/scout_apm/utils/scm.rb

@@ -0,0 +1,14 @@
+# Module for helping to deal with Source Code Management settings
+module ScoutApm
+  module Utils
+    class Scm
+      # Takes an *already relative* path +path+
+      # Returns a relative path, prepending the configured +scm_subdirectory+ environment string
+      def self.relative_scm_path(path, scm_subdirectory = ScoutApm::Environment.instance.scm_subdirectory)
+        @@scm_subdirectory ||= scm_subdirectory.sub(/^\//, '')
+        @@scm_subdirectoy_blank ||= @@scm_subdirectory.empty?
+        @@scm_subdirectoy_blank ? path : File.join(@@scm_subdirectory, path)
+      end
+    end
+  end
+end

data/lib/scout_apm/version.rb

@@ -1,4 +1,4 @@
 module ScoutApm
-  VERSION = "2.2.0.pre3"
+  VERSION = "2.3.0.pre"
 end
 

data/scout_apm.gemspec

@@ -19,9 +19,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib","data"]
   s.extensions << 'ext/allocations/extconf.rb'
-  s.extensions << 'ext/stacks/extconf.rb'
-
-  s.add_runtime_dependency "rusage", '~> 0.2.0'
+  s.extensions << 'ext/rusage/extconf.rb'
 
   s.add_development_dependency "minitest"
   s.add_development_dependency 'mocha'
@@ -29,4 +27,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "m"
   s.add_development_dependency "simplecov"
   s.add_development_dependency "rake-compiler"
-end
+  s.add_development_dependency "addressable"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-minitest"
+end

data/test/test_helper.rb

@@ -16,6 +16,14 @@ Kernel.module_eval do
   def self.const_unset(const)
     self.instance_eval { remove_const(const) }
   end
+
+  def silence_warnings(&block)
+    warn_level = $VERBOSE
+    $VERBOSE = nil
+    result = block.call
+    $VERBOSE = warn_level
+    result
+  end
 end
 
 # A test helper class to create a temporary "configuration" we can control entirely purposes
@@ -83,3 +91,13 @@ class Minitest::Test
   DATA_FILE_PATH = "#{DATA_FILE_DIR}/scout_apm.db"
 end
 
+
+module CustomAsserts
+  def assert_false(thing)
+    assert !thing
+  end
+end
+
+class Minitest::Test
+  include CustomAsserts
+end

data/test/unit/config_test.rb

@@ -7,24 +7,75 @@ class ConfigTest < Minitest::Test
     conf = ScoutApm::Config.without_file
 
     # 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_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')
+    assert_equal 'debug', conf.value('log_level')
+    assert_equal 'APM Test Conf (Production)', conf.value('name')
   end
-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")
+
+    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?
+  end
+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/git_revision_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+require 'scout_apm/git_revision'
+
+class GitRevisionTest < Minitest::Test
+  # TODO - other tests that would be nice:
+  # * ensure we only detect once, on initialize.
+  # * tests for reading cap files
+  
+  def test_sha_from_heroku
+    ENV['HEROKU_SLUG_COMMIT'] = 'heroku_slug'
+    revision = ScoutApm::GitRevision.new
+    assert_equal 'heroku_slug', revision.sha
+  end
+end

data/test/unit/histogram_test.rb

@@ -79,6 +79,20 @@ 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 {