scout_apm 2.6.10 → 3.0.0.pre0

data/test/unit/auto_instrument/assignments.rb

@@ -1,31 +0,0 @@
-
-class Assignments
-  def test_op_asgn
-    foo.bar += User.size
-    foo.bar -= User.size
-  end
-
-  def nested_assignment
-    @email ||= if (email = session["email"]).present?
-        User.where(email: email).first
-      else
-        nil
-      end
-  end
-
-  def paginate_collection(coll)
-    page = (params[:page].present? ? params[:page].to_i : 1)
-    per_page = (params[:per_page].present? ? params[:per_page].to_i : 20)
-    pagination, self.collection = pagy(
-      coll,
-      items: per_page,
-      page: page
-    )
-    headers[PAGINATION_TOTAL_HEADER] = pagination.count.to_s
-    headers[PAGINATION_TOTAL_PAGES_HEADER] = pagination.pages.to_s
-    headers[PAGINATION_PER_PAGE_HEADER] = per_page.to_s
-    headers[PAGINATION_PAGE_HEADER] = pagination.page.to_s
-    headers[PAGINATION_NEXT_PAGE_HEADER] = pagination.next.to_s
-    collection
-  end
-end

data/test/unit/auto_instrument/controller-ast.txt

@@ -1,57 +0,0 @@
-s(:class,
-  s(:const, nil, :ClientsController),
-  s(:const, nil, :ApplicationController),
-  s(:begin,
-    s(:send, nil, :before_action,
-      s(:sym, :check_authorization)),
-    s(:def, :index,
-      s(:args),
-      s(:if,
-        s(:send,
-          s(:send,
-            s(:send, nil, :params), :[],
-            s(:sym, :status)), :==,
-          s(:str, "activated")),
-        s(:ivasgn, :@clients,
-          s(:send,
-            s(:const, nil, :Client), :activated)),
-        s(:ivasgn, :@clients,
-          s(:send,
-            s(:const, nil, :Client), :inactivated)))),
-    s(:def, :create,
-      s(:args),
-      s(:begin,
-        s(:ivasgn, :@client,
-          s(:send,
-            s(:const, nil, :Client), :new,
-            s(:send,
-              s(:send, nil, :params), :[],
-              s(:sym, :client)))),
-        s(:if,
-          s(:send,
-            s(:ivar, :@client), :save),
-          s(:send, nil, :redirect_to,
-            s(:ivar, :@client)),
-          s(:send, nil, :render,
-            s(:str, "new"))))),
-    s(:def, :edit,
-      s(:args),
-      s(:begin,
-        s(:ivasgn, :@client,
-          s(:send,
-            s(:const, nil, :Client), :new,
-            s(:send,
-              s(:send, nil, :params), :[],
-              s(:sym, :client)))),
-        s(:if,
-          s(:send,
-            s(:send, nil, :request), :post?),
-          s(:block,
-            s(:send,
-              s(:ivar, :@client), :transaction),
-            s(:args),
-            s(:send,
-              s(:ivar, :@client), :update_attributes,
-              s(:send,
-                s(:send, nil, :params), :[],
-                s(:sym, :client)))), nil)))))

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

@@ -1,49 +0,0 @@
-
-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

@@ -1,49 +0,0 @@
-
-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

@@ -1,13 +0,0 @@
-
-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

@@ -1,13 +0,0 @@
-
-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

@@ -1,54 +0,0 @@
-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/db_query_metric_set_test.rb

@@ -1,67 +0,0 @@
-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
-    )
-    context = ScoutApm::AgentContext.new().tap{|c| c.config = config }
-    set = DbQueryMetricSet.new(context)
-
-    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
-    )
-    context = ScoutApm::AgentContext.new().tap{|c| c.config = config }
-    set = DbQueryMetricSet.new(context)
-    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
-    config = make_fake_config(
-      'database_metric_limit' => 5, # The hard limit on db metrics
-      'database_metric_report_limit' => 2
-    )
-    context = ScoutApm::AgentContext.new().tap{|c| c.config = config }
-    set1 = DbQueryMetricSet.new(context)
-    set1 << fake_stat("a", 10)
-    set1 << fake_stat("b", 20)
-    set2 = DbQueryMetricSet.new(context)
-    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}.sort
-  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

@@ -1,113 +0,0 @@
-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/error_service/error_buffer_test.rb

@@ -1,25 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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/extensions/periodic_callbacks_test.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-class PeriodicCallbacksTest < Minitest::Test
-
-  # We don't have a test that ensures we actually report data to the server, so we can't be 100% sure this doesn't break
-  # reporting.
-  def test_broken_callback_does_not_throw_exception
-    ScoutApm::Extensions::Config.add_periodic_callback(BrokenCallback.new)
-    # Runs via agent context as calling +add_periodic_callback+ initializing the context + extension config.
-    ScoutApm::Agent.instance.context.extensions.run_periodic_callbacks(reporting_period,metadata)
-  end
-
-  def test_callback_runs
-    Thread.current[:periodic_callback_output] = nil
-    ScoutApm::Extensions::Config.add_periodic_callback(PeriodicCallback.new)
-    ScoutApm::Agent.instance.context.extensions.run_periodic_callbacks(reporting_period,metadata)
-    assert Thread.current[:periodic_callback_output]
-  end
-
-  def run_proc_callback
-    Thread.current[:proc_periodic] = nil
-    ScoutApm::Extensions::Config.add_periodic_callback(Proc.new { |reporting_period, metadata| Thread.current[:proc_periodic] = Time.at(metadata[:agent_time].to_i) })
-    ScoutApm::Agent.instance.context.extensions.run_periodic_callbacks(reporting_period,metadata)
-    assert Thread.current[:proc_periodic]
-  end
-
-  # Doesn't respond to +call+.
-  class BrokenCallback
-  end
-
-  # Sets a Thread local so we can verify that the callback ran.
-  class PeriodicCallback
-    def call(reporting_period,metadata)
-      Thread.current[:periodic_callback_output] = true
-    end
-  end
-
-  private
-
-  def reporting_period
-    rp = ScoutApm::StoreReportingPeriod.new(Time.at(metadata[:agent_time].to_i), ScoutApm::AgentContext.new)
-    rp.absorb_metrics!(metrics)
-  end
-
-  def metrics
-    meta = ScoutApm::MetricMeta.new("Controller/users/index")
-    stats = ScoutApm::MetricStats.new
-    stats.update!(0.1)
-    {
-      meta => stats
-    }
-  end
-
-  def metadata
-    {:app_root=>"/srv/rails_app", :unique_id=>"ID", :agent_version=>"2.4.10", :agent_time=>"1523287920", :agent_pid=>21581, :platform=>"ruby"}
-  end
-
-end

data/test/unit/extensions/transaction_callbacks_test.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-class TransactionCallbacksTest < Minitest::Test
-
-  def setup
-    # Another test could set the recorder to +FakeRecorder+, which does not call +TrackedRequest#record!+.
-    ScoutApm::Agent.instance.context.recorder = ScoutApm::RecorderFactory.build(ScoutApm::Agent.instance.context)
-  end
-
-  # This is more of an integration test to ensure that we don't break TrackedRequest.
-  def test_broken_callback_does_not_break_tracked_request
-    ScoutApm::Extensions::Config.add_transaction_callback(BrokenCallback.new)
-
-    controller_layer = ScoutApm::Layer.new("Controller", "users/index")
-    # why doesn't this run? check if callbacks are configured
-    tr = ScoutApm::TrackedRequest.new(ScoutApm::Agent.instance.context, ScoutApm::FakeStore.new)
-    tr.start_layer(controller_layer)
-    tr.stop_layer
-  end
-
-  def test_callback_runs
-    Thread.current[:transaction_callback_output] = nil
-    ScoutApm::Extensions::Config.add_transaction_callback(TransactionCallback.new)
-
-    controller_layer = ScoutApm::Layer.new("Controller", "users/index")
-
-    tr = ScoutApm::TrackedRequest.new(ScoutApm::Agent.instance.context, ScoutApm::FakeStore.new)
-    tr.start_layer(controller_layer)
-    tr.stop_layer
-
-    assert Thread.current[:transaction_callback_output]
-  end
-
-  def test_run_proc_callback
-    Thread.current[:proc_transaction_duration] = nil
-    ScoutApm::Extensions::Config.add_transaction_callback(Proc.new { |payload| Thread.current[:proc_transaction_duration] = payload.duration_ms })
-
-    controller_layer = ScoutApm::Layer.new("Controller", "users/index")
-
-    tr = ScoutApm::TrackedRequest.new(ScoutApm::Agent.instance.context, ScoutApm::FakeStore.new)
-    tr.start_layer(controller_layer)
-    tr.stop_layer
-
-    assert Thread.current[:proc_transaction_duration]
-  end
-
-  # Doesn't respond to +call+.
-  class BrokenCallback
-  end
-
-  # Sets a Thread local so we can verify that the callback ran.
-  class TransactionCallback
-    def call(payload)
-      Thread.current[:transaction_callback_output] = true
-    end
-  end
-
-end

data/test/unit/fake_store_test.rb

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

data/test/unit/git_revision_test.rb

@@ -1,15 +0,0 @@
-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(ScoutApm::AgentContext.new)
-    assert_equal 'heroku_slug', revision.sha
-  end
-end