scout_apm 3.0.0.pre28 → 4.0.4

data/test/unit/environment_test.rb

@@ -44,8 +44,8 @@ class EnvironmentTest < Minitest::Test
   end
 
   def clean_fake_rails
-    Kernel.const_unset("Rails") if defined?(Kernel::Rails)
-    Kernel.const_unset("ActionController") if defined?(Kernel::ActionController)
+    Kernel.send(:remove_const, "Rails") if defined?(Kernel::Rails)
+    Kernel.send(:remove_const, "ActionController") if defined?(Kernel::ActionController)
   end
 
   def fake_sinatra

data/test/unit/error_service/error_buffer_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class ErrorBufferTest < Minitest::Test
+  class FakeError < StandardError
+  end
+
+  def test_captures_and_stores_exceptions_and_env
+    eb = ScoutApm::ErrorService::ErrorBuffer.new(context)
+    eb.capture(ex, env)
+  end
+
+  #### Helpers
+
+  def context
+    ScoutApm::AgentContext.new
+  end
+
+  def env
+    {}
+  end
+
+  def ex(msg="Whoops")
+    FakeError.new(msg)
+  end
+end

data/test/unit/error_service/ignored_exceptions_test.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+class IgnoredExceptionsTest < Minitest::Test
+  class FakeError < StandardError
+  end
+
+  class SubclassFakeError < FakeError
+  end
+
+  def test_ignores_with_string_match
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["RuntimeError"])
+    assert ig.ignored?(RuntimeError.new("something went wrong"))
+    assert !ig.ignored?(FakeError.new("something went wrong"))
+  end
+
+  def test_ignores_with_block
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, [])
+    ig.add_callback { |e| e.message == "ignore me" }
+
+    should_ignore = RuntimeError.new("ignore me")
+    should_not_ignore = RuntimeError.new("super legit")
+
+    assert ig.ignored?(should_ignore)
+    assert !ig.ignored?(should_not_ignore)
+  end
+
+  def test_ignores_subclasses
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["IgnoredExceptionsTest::FakeError"])
+    assert ig.ignored?(SubclassFakeError.new("Subclass"))
+  end
+
+  # Check that a bad exception in the list doesn't stop the whole thing from working
+  def test_does_not_consider_unknown_errors
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, ["ThisDoesNotExist", "IgnoredExceptionsTest::FakeError"])
+    assert ig.ignored?(FakeError.new("ignore this one"))
+  end
+
+  def test_add_module
+    ig = ScoutApm::ErrorService::IgnoredExceptions.new(context, [])
+    ig.add(IgnoredExceptionsTest::FakeError)
+    assert ig.ignored?(FakeError.new("ignore this one"))
+  end
+
+  #### Helpers
+
+  def context
+    ScoutApm::AgentContext.new
+  end
+end

data/test/unit/instruments/active_record_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'sqlite3'
+require 'active_record'
+
+begin
+  require 'octoshark'
+rescue LoadError
+  # Ignore
+end
+
+class ActiveRecordTest < Minitest::Test
+  def database_path
+    File.expand_path('test.sqlite3', DATA_FILE_DIR)
+  end
+
+  def setup
+    database = SQLite3::Database.new(database_path)
+    database.execute("DROP TABLE IF EXISTS users;")
+    database.execute("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(100));")
+
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => database_path)
+  end
+
+  class User < ActiveRecord::Base
+  end
+
+  def test_instrumentation
+    recorder = FakeRecorder.new
+    agent_context.recorder = recorder
+
+    instrument = ScoutApm::Instruments::ActiveRecord.new(agent_context)
+    instrument.install
+
+    ScoutApm::Tracer.instrument("Controller", "foo/bar") do
+      user = User.create
+    end
+
+    assert 1, recorder.requests.size
+  end
+end

data/test/unit/layer_children_set_test.rb

@@ -71,6 +71,15 @@ class LayerChildrenSetTest < Minitest::Test
     limited_layers.each { |ml| assert_equal 5, ml.count }
   end
 
+  def test_works_with_marshal
+    s = SET.new(5)
+    10.times do
+      s << make_layer("LayerType", "LayerName")
+    end
+
+    Marshal.dump(s)
+  end
+
   #############
   #  Helpers  #
   #############

data/test/unit/request_histograms_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+require 'scout_apm/request_histograms'
+
+class RequestHistogramsTest < Minitest::Test
+  def test_as_json_without_activesupport
+    rh = ScoutApm::RequestHistograms.new
+
+    rh.add("foo", 1)
+    rh.add("foo", 2)
+    rh.add("bar", 3)
+
+    j = rh.as_json
+    assert_equal 2, j.size
+    assert_equal ["bar", "foo"], j.keys.sort
+  end
+end

data/test/unit/serializers/payload_serializer_test.rb

@@ -8,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 = {
@@ -49,7 +49,7 @@ class PayloadSerializerTest < Minitest::Test
         stats.total_exclusive_time = 0.078132088
       }
     }
-    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, metrics, {}, [], [], [], {})
+    payload = ScoutApm::Serializers::PayloadSerializerToJson.serialize({}, metrics, {}, [], [], [], {}, [])
     formatted_metrics = [
       {
         "key" => {
@@ -69,7 +69,6 @@ class PayloadSerializerTest < Minitest::Test
         "min_call_time" => 0.000613518,
         "total_call_time" => 0.033245704,
         "total_exclusive_time" => 0.033245704,
-        "traces" => []
       },
       {
         "key" => {
@@ -84,7 +83,6 @@ class PayloadSerializerTest < Minitest::Test
         "min_call_time" => 0.034881757,
         "total_call_time" => 0.113403176,
         "total_exclusive_time" => 0.078132088,
-        "traces" => []
       }
     ]
     assert_equal formatted_metrics,
@@ -96,7 +94,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 = {
@@ -110,4 +108,40 @@ class PayloadSerializerTest < Minitest::Test
     json = { "foo" => "\bbar\nbaz\r" }
     assert_equal json, JSON.parse(ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(json))
   end
+
+  def test_escapes_escaped_quotes
+    # Some escapes haven't ever worked on 1.8.7, and is not the issue I'm
+    # fixing now. Remove this when we drop support for ancient ruby
+    skip if RUBY_VERSION == "1.8.7"
+
+    json = {"foo" => %q|`additional_details` = '{\"amount\":1}'|}
+    result = ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(json)
+    assert_equal json, JSON.parse(result)
+  end
+
+  def test_escapes_various_special_characters
+    # Some escapes haven't ever worked on 1.8.7, and is not the issue I'm
+    # fixing now. Remove this when we drop support for ancient ruby
+    skip if RUBY_VERSION == "1.8.7"
+
+    json = {"foo" => [
+      %Q|\fbar|,
+      %Q|\rbar|,
+      %Q|\nbar|,
+      %Q|\tbar|,
+      %Q|"bar|,
+      %Q|'bar|,
+      %Q|{bar|,
+      %Q|}bar|,
+      %Q|\\bar|,
+      if RUBY_VERSION == '1.8.7'
+        ""
+      else
+        %Q|\\\nbar|
+      end,
+    ]}
+
+    result = ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(json)
+    assert_equal json, JSON.parse(result)
+  end
 end

data/test/unit/slow_request_policy_test.rb

@@ -1,6 +1,7 @@
 require 'test_helper'
 
 require 'scout_apm/slow_request_policy'
+require 'scout_apm/slow_policy/policy'
 require 'scout_apm/layer'
 
 class FakeRequest
@@ -16,35 +17,62 @@ class FakeRequest
   end
 end
 
+class FixedPolicy < ScoutApm::SlowPolicy::Policy
+  attr_reader :stored
+
+  def initialize(x)
+    @x = x
+  end
+
+  def call(req)
+    @x
+  end
+
+  def stored!(req)
+    @stored = true
+  end
+end
+
 class SlowRequestPolicyTest < Minitest::Test
   def setup
     @context = ScoutApm::AgentContext.new
   end
 
-  def test_stored_records_current_time
+  def test_age_policy_stored_records_current_time
     test_start = Time.now
-    policy = ScoutApm::SlowRequestPolicy.new(@context)
+    policy = ScoutApm::SlowPolicy::AgePolicy.new(@context)
     request = FakeRequest.new("users/index")
 
     policy.stored!(request)
     assert policy.last_seen[request.unique_name] > test_start
   end
 
-  def test_score
+  def test_sums_up_score
     policy = ScoutApm::SlowRequestPolicy.new(@context)
     request = FakeRequest.new("users/index")
 
-    request.set_duration(10) # 10 seconds
-    policy.last_seen[request.unique_name] = Time.now - 120 # 2 minutes since last seen
-    @context.request_histograms.add(request.unique_name, 1)
-    @context.transaction_time_consumed.add(request.unique_name, 1)
+    policy.add(FixedPolicy.new(1))
+    policy.add(FixedPolicy.new(2))
 
-    # Actual value I have in console is 4.01
-    # Score uses Time.now to compare w/ last_seen, and will tick up slowly as
-    # time passes, hence the range below.
-    score = policy.score(request)
+    assert_equal 3, policy.score(request)
+  end
+
+  def test_calls_store_on_policies
+    policy = ScoutApm::SlowRequestPolicy.new(@context)
+    request = FakeRequest.new("users/index")
+
+    policy.add(fp1 = FixedPolicy.new(1))
+    policy.add(fp2 = FixedPolicy.new(2))
+    policy.stored!(request)
+
+    assert_equal true, fp1.stored
+    assert_equal true, fp2.stored
+  end
+
+  def test_checks_new_policy_api
+    policy = ScoutApm::SlowRequestPolicy.new(@context)
 
-    assert score > 3.95
-    assert score < 4.05
+    assert_raises { policy.add(Object.new) }
+    assert_raises { policy.add(->(req){1}) } # only implements call
   end
 end

data/test/unit/sql_sanitizer_test.rb

@@ -28,7 +28,23 @@ module ScoutApm
         sql = %q|SELECT "users".* FROM "users" INNER JOIN "blogs" ON "blogs"."user_id" = "users"."id" WHERE (blogs.title = 'hello world')|
         ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :postgres }
         assert_equal %q|SELECT "users".* FROM "users" INNER JOIN "blogs" ON "blogs"."user_id" = "users"."id" WHERE (blogs.title = ?)|, ss.to_s
+      end
+
+      def test_postgres_strips_after_where
+        raw_sql = %q|SELECT DISTINCT ON (flagged_traces.metric_name) flagged_traces.metric_name, "flagged_traces"."trace_id", "flagged_traces"."trace_type", "flagged_traces"."trace_occurred_at", flagged_traces.details ->> 'uri' as uri, (flagged_traces.details ->> 'n_sum_millis')::float as potential_savings, (flagged_traces.details ->> 'n_count')::float as num_queries FROM "flagged_traces" WHERE "flagged_traces"."app_id" = 5 AND "flagged_traces"."trace_type" = 'Request' AND ("flagged_traces"."trace_occurred_at" BETWEEN '2019-04-17 12:28:00.000000' AND '2019-04-18 12:28:00.000000') AND "flagged_traces"."flag_type" = 'nplusone' ORDER BY "flagged_traces"."metric_name" ASC, potential_savings DESC|
+        sanitized_sql = SqlSanitizer.new(raw_sql).tap { |it| it.database_engine = :postgres}
+        expected_sql = %q|SELECT DISTINCT ON (flagged_traces.metric_name) flagged_traces.metric_name, "flagged_traces"."trace_id", "flagged_traces"."trace_type", "flagged_traces"."trace_occurred_at", flagged_traces.details ->> 'uri' as uri, (flagged_traces.details ->> 'n_sum_millis')::float as potential_savings, (flagged_traces.details ->> 'n_count')::float as num_queries FROM "flagged_traces" WHERE "flagged_traces"."app_id" = ? AND "flagged_traces"."trace_type" = ? AND ("flagged_traces"."trace_occurred_at" BETWEEN ? AND ?) AND "flagged_traces"."flag_type" = ? ORDER BY "flagged_traces"."metric_name" ASC, potential_savings DESC|
+        assert_equal expected_sql, sanitized_sql.to_s
+      end
 
+      def test_postgres_strips_subquery_strings
+        raw_sql = %q|"SELECT 'orgs'.* FROM "orgs" WHERE  "orgs"."name" = 'Scout' AND "orgs"."created_by_user_id" IN (SELECT 'users'.'id' FROM "users" WHERE (id > AVG(id)) AND "type" = 'USER' AND "created_at" BETWEEN '2019-04-17 12:28:00.000000' AND '2019-04-18 12:28:00.000000')"|
+        sanitized_sql = SqlSanitizer.new(raw_sql).tap { |it| it.database_engine = :postgres}
+        expected_sql = %q|"SELECT 'orgs'.* FROM "orgs" WHERE "orgs"."name" = ? AND "orgs"."created_by_user_id" IN (SELECT 'users'.'id' FROM "users" WHERE (id > AVG(id)) AND "type" = ? AND "created_at" BETWEEN ? AND ?)"|
+        assert_equal expected_sql, sanitized_sql.to_s
+      end
+
+      def test_postgres_strips_integers
         # Strip integers
         sql = %q|SELECT "blogs".* FROM "blogs" WHERE (view_count > 10)|
         ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :postgres }
@@ -89,6 +105,30 @@ module ScoutApm
         assert_equal %q|INSERT INTO `users` VALUES (?, ?)|, ss.to_s
       end
 
+      def test_sqlserver_integers
+        skip "SQLServer Support requires Ruby 1.9+ For Regexes"
+
+        sql = "EXEC sp_executesql N'SELECT  [users].* FROM [users] WHERE (age > 50)  ORDER BY [users].[id] ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY', N'@0 int', @0 = 10"
+        ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :sqlserver }
+        assert_equal %q|SELECT  [users].* FROM [users] WHERE (age > ?)  ORDER BY [users].[id] ASC OFFSET ? ROWS FETCH NEXT @0 ROWS ONLY|, ss.to_s
+      end
+
+      def test_sqlserver_strings
+        skip "SQLServer Support requires Ruby 1.9+ For Regexes"
+
+        sql = "EXEC sp_executesql N'SELECT  [users].* FROM [users] WHERE [users].[email] = @0  ORDER BY [users].[id] ASC OFFSET 0 ROWS FETCH NEXT @1 ROWS ONLY', N'@0 nvarchar(4000), @1 int', @0 = N'foo', @1 = 10"
+        ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :sqlserver }
+        assert_equal %q|SELECT  [users].* FROM [users] WHERE [users].[email] = @0  ORDER BY [users].[id] ASC OFFSET ? ROWS FETCH NEXT @1 ROWS ONLY|, ss.to_s
+      end
+
+      def test_sqlserver_in_clause
+        skip "SQLServer Support requires Ruby 1.9+ For Regexes"
+
+        sql = "EXEC sp_executesql N'SELECT  [users].* FROM [users] WHERE (id IN (1,2,3))  ORDER BY [users].[id] ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY', N'@0 int', @0 = 10"
+        ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :sqlserver }
+        assert_equal %q|SELECT  [users].* FROM [users] WHERE (id IN (?))  ORDER BY [users].[id] ASC OFFSET ? ROWS FETCH NEXT @0 ROWS ONLY|, ss.to_s
+      end
+
       def test_scrubs_invalid_encoding
         skip "Ruby 1.8.7 has no concept of encoding" if RUBY_VERSION.start_with?("1.8.")
 
@@ -99,6 +139,44 @@ module ScoutApm
         assert_equal %q|SELECT `blogs`.* FROM `blogs` WHERE (title = ?)|, ss.to_s
       end
 
+      def test_set_columns
+        sql = %q|UPDATE "mytable" SET "myfield" = 'fieldcontent', "countofthings" = 10 WHERE "user_id" = 10|
+
+        ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :postgres }
+        assert_equal %q|UPDATE "mytable" SET "myfield" = ?, "countofthings" = ? WHERE "user_id" = ?|, ss.to_s
+      end
+
+      def test_postgres_multiline_sql
+        sql = %q|
+        SELECT "html_form_payloads".*
+        FROM "html_form_payloads"
+        INNER JOIN "leads" ON "leads"."payload_id" = "html_form_payloads"."id"
+               AND "leads"."payload_type" = ?
+        WHERE html_form_payloads.id < 10
+          AND "form_type" = 'xyz'
+          AND (params::varchar = '{"name":"Chris","resident":"Yes","e-content":"Secret content"}')
+          AND (leads.url = 'http://example.com')
+        ORDER BY "html_form_payloads"."id" ASC
+        LIMIT ?
+        |
+
+        ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :postgres }
+        assert_equal %q|SELECT "html_form_payloads".* FROM "html_form_payloads" INNER JOIN "leads" ON "leads"."payload_id" = "html_form_payloads"."id" AND "leads"."payload_type" = ? WHERE html_form_payloads.id < ? AND "form_type" = ? AND (params::varchar = ?) AND (leads.url = ?) ORDER BY "html_form_payloads"."id" ASC LIMIT ?|, ss.to_s
+      end
+
+      def test_mysql_multiline
+        sql = %q|
+        SELECT `blogs`.*
+        FROM `blogs`
+        WHERE (title = 'abc')
+        |
+
+        ss = SqlSanitizer.new(sql).tap{ |it| it.database_engine = :mysql }
+        assert_equal %q|SELECT `blogs`.*
+        FROM `blogs`
+        WHERE (title = ?)|, ss.to_s
+      end
+
       def assert_faster_than(target_seconds)
         t1 = ::Time.now
         yield

data/test/unit/tracer_test.rb

@@ -65,6 +65,31 @@ class TracerTest < Minitest::Test
     assert_recorded(recorder, "Test", "name")
   end
 
+  if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+    def test_instrument_method_with_keyword_args
+      initial_value = Warning[:deprecated]
+      Warning[:deprecated] = true
+      recorder = FakeRecorder.new
+      ScoutApm::Agent.instance.context.recorder = recorder
+
+      klass = Class.new { include ScoutApm::Tracer }
+
+      invoked = false
+      klass.send(:define_method, :work) { |run:| invoked = true }
+      klass.instrument_method(:work, :type => "Test", :name => "name")
+
+      args = { run: false }
+      assert_output(nil, '') do
+        klass.new.work(**args)
+      end
+
+      assert invoked, "instrumented code was not invoked"
+      assert_recorded(recorder, "Test", "name")
+    ensure
+      Warning[:deprecated] = initial_value
+    end
+  end
+
   private
 
   def assert_recorded(recorder, type, name)