scout_apm 3.0.0.pre26 → 4.0.2

data/test/unit/auto_instrument/controller-instrumented.rb

@@ -0,0 +1,49 @@
+
+class ClientsController < ApplicationController
+  before_action :check_authorization
+
+  def index
+    if ::ScoutApm::AutoInstrument("params[:status] == \"activated\"",["ROOT/test/unit/auto_instrument/controller.rb:6:in `index'"]){params[:status] == "activated"}
+      @clients = ::ScoutApm::AutoInstrument("Client.activated",["ROOT/test/unit/auto_instrument/controller.rb:7:in `index'"]){Client.activated}
+    else
+      @clients = ::ScoutApm::AutoInstrument("Client.inactivated",["ROOT/test/unit/auto_instrument/controller.rb:9:in `index'"]){Client.inactivated}
+    end
+  end
+
+  def create
+    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["ROOT/test/unit/auto_instrument/controller.rb:14:in `create'"]){Client.new(params[:client])}
+    if ::ScoutApm::AutoInstrument("@client.save",["ROOT/test/unit/auto_instrument/controller.rb:15:in `create'"]){@client.save}
+      ::ScoutApm::AutoInstrument("redirect_to @client",["ROOT/test/unit/auto_instrument/controller.rb:16:in `create'"]){redirect_to @client}
+    else
+      # This line overrides the default rendering behavior, which
+      # would have been to render the "create" view.
+      ::ScoutApm::AutoInstrument("render \"new\"",["ROOT/test/unit/auto_instrument/controller.rb:20:in `create'"]){render "new"}
+    end
+  end
+
+  def edit
+    @client = ::ScoutApm::AutoInstrument("Client.new(params[:client])",["ROOT/test/unit/auto_instrument/controller.rb:25:in `edit'"]){Client.new(params[:client])}
+
+    if ::ScoutApm::AutoInstrument("request.post?",["ROOT/test/unit/auto_instrument/controller.rb:27:in `edit'"]){request.post?}
+      ::ScoutApm::AutoInstrument("@client.transaction do...",["ROOT/test/unit/auto_instrument/controller.rb:28:in `edit'"]){@client.transaction do
+        @client.update_attributes(params[:client])
+      end}
+    end
+  end
+
+  def data
+    @clients = ::ScoutApm::AutoInstrument("Client.all",["ROOT/test/unit/auto_instrument/controller.rb:35:in `data'"]){Client.all}
+
+    formatter = ::ScoutApm::AutoInstrument("proc do |row|...",["ROOT/test/unit/auto_instrument/controller.rb:37:in `data'"]){proc do |row|
+      row.to_json
+    end}
+
+    ::ScoutApm::AutoInstrument("respond_with @clients.each(&formatter).join(\"\\n\"), :content_type => 'application/json; boundary=NL'",["ROOT/test/unit/auto_instrument/controller.rb:41:in `data'"]){respond_with @clients.each(&formatter).join("\n"), :content_type => 'application/json; boundary=NL'}
+  end
+  
+  def things
+    x = {}
+    x[:this] ||= 'foo'
+    x[:that] &&= ::ScoutApm::AutoInstrument("'foo'.size",["ROOT/test/unit/auto_instrument/controller.rb:47:in `things'"]){'foo'.size}
+  end
+end

data/test/unit/auto_instrument/controller.rb

@@ -0,0 +1,49 @@
+
+class ClientsController < ApplicationController
+  before_action :check_authorization
+
+  def index
+    if params[:status] == "activated"
+      @clients = Client.activated
+    else
+      @clients = Client.inactivated
+    end
+  end
+
+  def create
+    @client = Client.new(params[:client])
+    if @client.save
+      redirect_to @client
+    else
+      # This line overrides the default rendering behavior, which
+      # would have been to render the "create" view.
+      render "new"
+    end
+  end
+
+  def edit
+    @client = Client.new(params[:client])
+
+    if request.post?
+      @client.transaction do
+        @client.update_attributes(params[:client])
+      end
+    end
+  end
+
+  def data
+    @clients = Client.all
+
+    formatter = proc do |row|
+      row.to_json
+    end
+
+    respond_with @clients.each(&formatter).join("\n"), :content_type => 'application/json; boundary=NL'
+  end
+  
+  def things
+    x = {}
+    x[:this] ||= 'foo'
+    x[:that] &&= 'foo'.size
+  end
+end

data/test/unit/auto_instrument/rescue_from-instrumented.rb

@@ -0,0 +1,13 @@
+
+class BrokenController < ApplicationController
+  rescue_from Exception do |e|
+    if e.is_a? Pundit::NotAuthorizedError
+      unauthorized_error
+    elsif e.is_a? ActionController::ParameterMissing
+      error(status: 422, message: e.message)
+    else
+      log_error(e)
+      error message: 'Internal error', exception: e
+    end
+  end
+end

data/test/unit/auto_instrument/rescue_from.rb

@@ -0,0 +1,13 @@
+
+class BrokenController < ApplicationController
+  rescue_from Exception do |e|
+    if e.is_a? Pundit::NotAuthorizedError
+      unauthorized_error
+    elsif e.is_a? ActionController::ParameterMissing
+      error(status: 422, message: e.message)
+    else
+      log_error(e)
+      error message: 'Internal error', exception: e
+    end
+  end
+end

data/test/unit/auto_instrument_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+require 'scout_apm/auto_instrument'
+
+class AutoInstrumentTest < Minitest::Test
+  ROOT = File.expand_path("../../", __dir__)
+  
+  def source_path(name)
+    File.expand_path("auto_instrument/#{name}.rb", __dir__)
+  end
+
+  def instrumented_path(name)
+    File.expand_path("auto_instrument/#{name}-instrumented.rb", __dir__)
+  end
+
+  def instrumented_source(name)
+    File.read(instrumented_path(name))
+  end
+
+  # Autoinstruments adds a backtrace to each created layer. This is the full path to the
+  # test controller.rb file, which will be different on different environments.
+  # This normalizes backtraces across environments.
+  def normalize_backtrace(string)
+    string.gsub(ROOT, "ROOT")
+  end
+
+  # Use this to automatically update the test fixtures.
+  def update_instrumented_source(name)
+    source = ::ScoutApm::AutoInstrument::Rails.rewrite(source_path(name))
+    source = normalize_backtrace(source)
+    File.write(instrumented_path(name),source)
+  end
+
+  def test_controller_rewrite
+    # update_instrumented_source("controller")
+
+    assert_equal instrumented_source("controller"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("controller")))
+  end
+
+  def test_rescue_from_rewrite
+    # update_instrumented_source("rescue_from")
+
+    assert_equal instrumented_source("rescue_from"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("rescue_from")))
+  end
+
+  def test_assignments_rewrite
+    # update_instrumented_source("assignments")
+
+    assert_equal instrumented_source("assignments"),
+      normalize_backtrace(::ScoutApm::AutoInstrument::Rails.rewrite(source_path("assignments")))
+  end
+end if defined? ScoutApm::AutoInstrument

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