newrelic_rpm 4.0.0.332 → 4.4.0.336

data/test/multiverse/suites/sidekiq/sidekiq_instrumentation_test.rb

@@ -1,220 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-# https://newrelic.atlassian.net/browse/RUBY-775
-
-require File.join(File.dirname(__FILE__), "sidekiq_server")
-SidekiqServer.instance.run
-
-# Important to require after Sidekiq server starts for middleware to install
-require 'newrelic_rpm'
-
-require 'logger'
-require 'stringio'
-
-require 'fake_collector'
-require File.join(File.dirname(__FILE__), "test_model")
-require File.join(File.dirname(__FILE__), "test_worker")
-
-class SidekiqTest < Minitest::Test
-  JOB_COUNT = 5
-
-  ROLLUP_METRIC            = 'OtherTransaction/SidekiqJob/all'
-  TRANSACTION_NAME         = 'OtherTransaction/SidekiqJob/TestWorker/perform'
-  DELAYED_TRANSACTION_NAME = 'OtherTransaction/SidekiqJob/TestModel/do_work'
-  DELAYED_FAILED_TXN_NAME  = 'OtherTransaction/SidekiqJob/Sidekiq::Extensions::DelayedClass/perform'
-
-  include MultiverseHelpers
-
-  setup_and_teardown_agent do
-    TestWorker.register_signal('jobs_completed')
-    @sidekiq_log = ::StringIO.new
-
-    string_logger = ::Logger.new(@sidekiq_log)
-    string_logger.formatter = Sidekiq.logger.formatter
-    Sidekiq.logger = string_logger
-  end
-
-  def teardown
-    teardown_agent
-    if !passed? || ENV["VERBOSE"]
-      @sidekiq_log.rewind
-      puts @sidekiq_log.read
-    end
-  end
-
-  def run_jobs
-    run_and_transmit do |i|
-      TestWorker.perform_async('jobs_completed', i + 1)
-    end
-  end
-
-  def run_delayed
-    run_and_transmit do |i|
-      TestModel.delay(:queue => SidekiqServer.instance.queue_name, :retry => false).do_work
-    end
-  end
-
-  def run_and_transmit
-    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-      TestWorker.run_jobs(JOB_COUNT) do |i|
-        yield i
-      end
-    end
-
-    run_harvest
-  end
-
-  def test_delayed
-    run_delayed
-    assert_metric_and_call_count(ROLLUP_METRIC, JOB_COUNT)
-    assert_metric_and_call_count(DELAYED_TRANSACTION_NAME, JOB_COUNT)
-  end
-
-  def test_delayed_with_malformed_yaml
-    YAML.stubs(:load).raises(RuntimeError.new("Ouch"))
-    run_delayed
-    assert_metric_and_call_count(ROLLUP_METRIC, JOB_COUNT)
-    assert_metric_and_call_count(DELAYED_FAILED_TXN_NAME, JOB_COUNT)
-  end
-
-  def test_all_jobs_ran
-    run_jobs
-    completed_jobs = Set.new(TestWorker.records_for('jobs_completed').map(&:to_i))
-    expected_completed_jobs = Set.new((1..JOB_COUNT).to_a)
-    assert_equal(expected_completed_jobs, completed_jobs)
-  end
-
-  def test_agent_posts_correct_metric_data
-    run_jobs
-    assert_metric_and_call_count(ROLLUP_METRIC, JOB_COUNT)
-    assert_metric_and_call_count(TRANSACTION_NAME, JOB_COUNT)
-  end
-
-  def test_doesnt_capture_args_by_default
-    run_jobs
-    refute_attributes_on_transaction_trace
-    refute_attributes_on_events
-  end
-
-  def test_isnt_influenced_by_global_capture_params
-    with_config(:capture_params => true) do
-      run_jobs
-    end
-    refute_attributes_on_transaction_trace
-    refute_attributes_on_events
-  end
-
-  def test_agent_posts_captured_args_to_job
-    with_config(:'sidekiq.capture_params' => true) do
-      run_jobs
-    end
-
-    assert_attributes_on_transaction_trace
-    refute_attributes_on_events
-  end
-
-  def test_arguments_are_captured_on_transaction_events_when_enabled
-    with_config(:'attributes.include' => 'job.sidekiq.args.*') do
-      run_jobs
-    end
-
-    assert_attributes_on_events
-  end
-
-  def test_captures_errors_from_job
-    TestWorker.fail = true
-    run_jobs
-    assert_error_for_each_job
-  ensure
-    TestWorker.fail = false
-  end
-
-  # In <= 2.x of Sidekiq, internal errors (or potentially errors further out
-  # the middleware stack) wouldn't get noticed, but there was no proper hook
-  # to catch it. 3.x+ gives us an error_handler, so only add our misbehaving
-  # middleware for those cases.
-  if Sidekiq::VERSION >= '3'
-    def test_captures_sidekiq_internal_errors
-      # When testing internal Sidekiq error capturing, we're looking to
-      # ensure Sidekiq properly forwards errors to our custom error handler
-      # in order for us to notice the error.
-
-      exception = StandardError.new('foo')
-      NewRelic::Agent.expects(:notice_error).with(exception)
-      Sidekiq::CLI.instance.handle_exception(exception)
-    end
-  end
-
-  def assert_metric_and_call_count(name, expected_call_count)
-    metric_data = $collector.calls_for('metric_data')
-    assert_equal(1, metric_data.size, "expected exactly one metric_data post from agent")
-
-    metric = metric_data.first.metrics.find { |m| m[0]['name'] == name }
-    assert(metric, "Could not find metric named #{name}. Did have metrics:\n"+
-                   metric_data.first.metrics.map{|m| m[0]['name']}.join("\t\n"))
-
-    call_count = metric[1][0]
-    assert_equal(expected_call_count, call_count)
-  end
-
-  def assert_attributes_on_transaction_trace
-    transaction_samples = $collector.calls_for('transaction_sample_data')
-    refute transaction_samples.empty?, "Expected a transaction trace"
-
-    transaction_samples.each do |post|
-      post.samples.each do |sample|
-        assert_equal sample.metric_name, TRANSACTION_NAME, "Huh, that transaction shouldn't be in there!"
-
-        actual = sample.agent_attributes.keys.to_set
-        expected = Set.new ["job.sidekiq.args.0", "job.sidekiq.args.1"]
-        assert_equal expected, actual
-      end
-    end
-  end
-
-  def refute_attributes_on_transaction_trace
-    transaction_samples = $collector.calls_for('transaction_sample_data')
-    refute transaction_samples.empty?, "Didn't find any transaction samples!"
-
-    transaction_samples.each do |post|
-      post.samples.each do |sample|
-        assert_equal sample.metric_name, TRANSACTION_NAME, "Huh, that transaction shouldn't be in there!"
-        assert sample.agent_attributes.keys.none? { |k| k =~ /^job.sidekiq.args.*/ }
-      end
-    end
-  end
-
-  def assert_attributes_on_events
-    event_posts = $collector.calls_for('analytic_event_data')
-    event_posts.each do |post|
-      post.events.each do |event|
-        assert_equal Set.new(["job.sidekiq.args.0", "job.sidekiq.args.1"]), event[2].keys.to_set
-      end
-    end
-  end
-
-  def refute_attributes_on_events
-    event_posts = $collector.calls_for('analytic_event_data')
-    event_posts.each do |post|
-      post.events.each do |event|
-        assert event[2].keys.none? { |k| k.start_with?("job.sidekiq.args") }, "Found unexpected sidekiq arguments"
-      end
-    end
-  end
-
-  def assert_error_for_each_job(txn_name=TRANSACTION_NAME)
-    error_posts = $collector.calls_for("error_data")
-    assert_equal 1, error_posts.length, "Wrong number of error posts!"
-
-    errors = error_posts.first
-    assert_equal JOB_COUNT, errors.errors.length, "Wrong number of errors noticed!"
-
-    assert_metric_and_call_count('Errors/all', JOB_COUNT)
-    if txn_name
-      assert_metric_and_call_count('Errors/allOther', JOB_COUNT)
-      assert_metric_and_call_count("Errors/#{TRANSACTION_NAME}", JOB_COUNT)
-    end
-  end
-end

data/test/multiverse/suites/sidekiq/sidekiq_server.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'sidekiq'
-require 'sidekiq/cli'
-
-class SidekiqServer
-  include Singleton
-
-  THREAD_JOIN_TIMEOUT = 30
-
-  attr_reader :queue_name
-
-  def initialize
-    @queue_name = "sidekiq#{Process.pid}"
-    @sidekiq = Sidekiq::CLI.instance
-  end
-
-  def run(file="test_worker.rb")
-    @sidekiq.parse(["--require", File.join(File.dirname(__FILE__), file),
-                    "--queue", "#{queue_name},1"])
-    @cli_thread = Thread.new { @sidekiq.run }
-  end
-
-  # If we just let the process go away, occasional timing issues cause the
-  # Launcher actor in Sidekiq to throw a fuss and exit with a failed code.
-  def stop
-    puts "Trying to stop Sidekiq gracefully from #{$$}"
-    Process.kill("INT", $$)
-    if @cli_thread.join(THREAD_JOIN_TIMEOUT).nil?
-      puts "#{$$} Sidekiq::CLI thread timeout on exit"
-    end
-  end
-end

data/test/multiverse/suites/sidekiq/test_model.rb

@@ -1,12 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-# This class is used to test Sidekiq's Delayed Extensions
-# which give the framework an interface like Delayed Job.
-# The Delayed Extensions cannot be used to operate directly
-# on a Sidekiq Worker.
-class TestModel
-  def self.do_work
-  end
-end

data/test/multiverse/suites/sidekiq/test_worker.rb

@@ -1,71 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-class TestWorker
-  include Sidekiq::Worker
-
-  sidekiq_options :queue => SidekiqServer.instance.queue_name, :retry => false
-  @jobs = {}
-  @jobs_mutex = Mutex.new
-
-  @done = Queue.new
-
-  def self.register_signal(key)
-    return if @registered_signal
-
-    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
-      @done.push(true)
-    end
-    @registered_signal = true
-  end
-
-  def self.run_jobs(count)
-    reset(count)
-    count.times do |i|
-      yield i
-    end
-    wait
-  end
-
-  def self.reset(done_at)
-    @jobs = {}
-    @done_at = done_at
-  end
-
-  def self.record(key, val)
-    @jobs_mutex.synchronize do
-      @jobs[key] ||= []
-      @jobs[key] << val
-    end
-  end
-
-  def self.records_for(key)
-    @jobs[key]
-  end
-
-  def self.wait
-    # Don't hang out forever, but shouldn't count on the timeout functionally
-    Timeout.timeout(60) do
-      @done_at.times do
-        @done.pop
-      end
-    end
-  end
-
-  def self.fail=(val)
-    @fail = val
-  end
-
-  def self.am_i_a_failure?
-    @fail
-  end
-
-  def perform(key, val)
-    if self.class.am_i_a_failure?
-      raise "Uh oh"
-    else
-      TestWorker.record(key, val)
-    end
-  end
-end

data/test/multiverse/suites/sinatra/Envfile

@@ -1,27 +0,0 @@
-if RUBY_VERSION >= '2.2.0'
-  gemfile <<-RB
-    gem 'sinatra', '~> 2.0.0.beta2'
-    gem 'rack',    '~> 2.0.0'
-    gem 'rack-test', :require => 'rack/test'
-  RB
-end
-
-gemfile <<-RB
-  gem 'sinatra', '~> 1.4.6'
-  gem 'rack',    '~> 1.5.0'
-  gem 'rack-test', :require => 'rack/test'
-RB
-
-gemfile <<-RB
-  gem 'sinatra', '~> 1.3.6'
-  gem 'rack',    '~> 1.5.0'
-  gem 'rack-test', :require => 'rack/test'
-RB
-
-gemfile <<-RB
-  gem 'backports', '~> 3.6.1'
-  gem 'sinatra',   '~> 1.2.9'
-  gem 'rack-test', :require => 'rack/test'
-RB
-
-# vim: ft=ruby

data/test/multiverse/suites/sinatra/config/newrelic.yml

@@ -1,21 +0,0 @@
----
-development:
-  error_collector:
-    enabled: true
-  apdex_t: 0.5
-  ssl: false
-  agent_enabled: true
-  monitor_mode: true
-  license_key: bootstrap_newrelic_admin_license_key_000
-  developer_mode: false
-  app_name: test
-  host: 127.0.0.1
-  api_host: 127.0.0.1
-  port: <%= $collector && $collector.port %>
-  transaction_tracer:
-    record_sql: obfuscated
-    enabled: true
-    stack_trace_threshold: 0.5
-    transaction_threshold: 1.0
-  capture_params: false
-  disable_serialization: false

data/test/multiverse/suites/sinatra/ignoring_test.rb

@@ -1,226 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-class SinatraIgnoreTestApp < Sinatra::Base
-  get '/record' do request.path_info end
-
-  newrelic_ignore '/ignore'
-  get '/ignore' do request.path_info end
-
-  newrelic_ignore '/splat*'
-  get '/splattered' do request.path_info end
-
-  newrelic_ignore '/named/:id'
-  get '/named/:id' do request.path_info end
-
-  newrelic_ignore '/v1', '/v2'
-  get '/v1' do request.path_info end
-  get '/v2' do request.path_info end
-  get '/v3' do request.path_info end
-
-  newrelic_ignore(/\/.+regex.*/)
-  get '/skip_regex' do request.path_info end
-  get '/regex_seen' do request.path_info end
-
-  newrelic_ignore '/ignored_erroring'
-  get '/ignored_erroring' do raise 'boom'; end
-
-  newrelic_ignore_apdex '/no_apdex'
-  get '/no_apdex' do request.path_info end
-
-  newrelic_ignore_enduser '/no_enduser'
-
-  get '/enduser' do
-    "<html><head></head><body>#{request.path_info}</body></html>"
-  end
-
-  get '/no_enduser' do
-    "<html><head></head><body>#{request.path_info}</body></html>"
-  end
-end
-
-class SinatraTestCase < Minitest::Test
-  include Rack::Test::Methods
-  include ::NewRelic::Agent::Instrumentation::Sinatra
-  include MultiverseHelpers
-
-  JS_AGENT_LOADER = "JS_AGENT_LOADER"
-
-  setup_and_teardown_agent(:application_id => 'appId',
-                           :beacon => 'beacon',
-                           :browser_key => 'browserKey',
-                           :js_agent_loader => JS_AGENT_LOADER)
-
-  def get_and_assert_ok(path)
-    get(path)
-    assert_equal 200, last_response.status
-    assert_match(/#{Regexp.escape(path)}/, last_response.body)
-  end
-
-  def assert_enduser_ignored(response)
-    refute_match(/#{JS_AGENT_LOADER}/, response.body)
-  end
-
-  def refute_enduser_ignored(response)
-    assert_match(/#{JS_AGENT_LOADER}/, response.body)
-  end
-
-  # Keep Test::Unit happy by specifying at least one test method here
-  # Real tests are defined in subclasses.
-  def test_nothing; end
-end
-
-class SinatraIgnoreTest < SinatraTestCase
-  def app
-    SinatraIgnoreTestApp
-  end
-
-  def app_name
-    app.to_s
-  end
-
-  def test_seen_route
-    get_and_assert_ok '/record'
-    segment = name_for_route 'record'
-    assert_metrics_recorded([
-      "Controller/Sinatra/#{app_name}/#{segment}",
-      "Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignores_exact_match
-    get_and_assert_ok '/ignore'
-    segment = name_for_route 'ignore'
-    assert_metrics_not_recorded([
-      "Controller/Sinatra/#{app_name}/#{segment}",
-      "Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignores_by_splats
-    get_and_assert_ok '/splattered'
-    segment = name_for_route 'splattered'
-    assert_metrics_not_recorded([
-      "Controller/Sinatra/#{app_name}/#{segment}",
-      "Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignores_can_be_declared_in_batches
-    get_and_assert_ok '/v1'
-    get_and_assert_ok '/v2'
-    get_and_assert_ok '/v3'
-
-    v1_segment = name_for_route 'v1'
-    v2_segment = name_for_route 'v2'
-    v3_segment = name_for_route 'v3'
-
-    assert_metrics_not_recorded([
-      "Controller/Sinatra/#{app_name}/#{v1_segment}",
-      "Controller/Sinatra/#{app_name}/#{v2_segment}",
-      "Apdex/Sinatra/#{app_name}/#{v1_segment}",
-      "Apdex/Sinatra/#{app_name}/#{v2_segment}"])
-
-    assert_metrics_recorded([
-      "Controller/Sinatra/#{app_name}/#{v3_segment}",
-      "Apdex/Sinatra/#{app_name}/#{v3_segment}"])
-  end
-
-  def test_seen_with_regex
-    get_and_assert_ok '/regex_seen'
-    segment = name_for_route 'regex_seen'
-    assert_metrics_recorded([
-      "Controller/Sinatra/#{app_name}/#{segment}",
-      "Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignores_by_regex
-    get_and_assert_ok '/skip_regex'
-    segment = name_for_route 'skip_regex'
-    assert_metrics_not_recorded([
-      "Controller/Sinatra/#{app_name}/#{segment}",
-      "Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignore_apdex
-    get_and_assert_ok '/no_apdex'
-    segment = name_for_route 'no_apdex'
-    assert_metrics_recorded(["Controller/Sinatra/#{app_name}/#{segment}"])
-    assert_metrics_not_recorded(["Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignore_enduser_should_only_apply_to_specified_route
-    get_and_assert_ok '/enduser'
-    segment = name_for_route 'enduser'
-    refute_enduser_ignored(last_response)
-    assert_metrics_recorded([
-      "Controller/Sinatra/#{app_name}/#{segment}",
-      "Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignore_enduser
-    get_and_assert_ok '/no_enduser'
-    segment = name_for_route 'no_enduser'
-    assert_enduser_ignored(last_response)
-    assert_metrics_recorded([
-      "Controller/Sinatra/#{app_name}/#{segment}",
-      "Apdex/Sinatra/#{app_name}/#{segment}"])
-  end
-
-  def test_ignore_errors_in_ignored_transactions
-    get '/ignored_erroring'
-    assert_metrics_not_recorded(["Errors/all"])
-  end
-
-  def name_for_route path
-    if last_request.env.key? 'sinatra.route'
-      "GET /#{path}"
-    else
-      "GET #{path}"
-    end
-  end
-end
-
-# Blanket ignore for whole app if newrelic_ignore called without parameters
-class SinatraIgnoreItAllApp < Sinatra::Base
-  newrelic_ignore
-
-  get '/' do request.path_info end
-end
-
-class SinatraIgnoreItAllTest < SinatraTestCase
-  def app
-    SinatraIgnoreItAllApp
-  end
-
-  def test_ignores_everything
-    # Avoid Supportability metrics from startup of agent for this check
-    NewRelic::Agent.drop_buffered_data
-
-    get_and_assert_ok '/'
-    assert_metrics_recorded_exclusive([])
-  end
-end
-
-
-# Blanket ignore for whole app if calls made without parameters
-class SinatraIgnoreApdexAndEndUserApp < Sinatra::Base
-  newrelic_ignore_apdex
-  newrelic_ignore_enduser
-
-  get '/' do request.path_info end
-end
-
-class SinatraIgnoreApdexAndEndUserTest < SinatraTestCase
-  def app
-    SinatraIgnoreApdexAndEndUserApp
-  end
-
-  def test_ignores_apdex
-    get_and_assert_ok '/'
-    assert_metrics_not_recorded(["Apdex/Sinatra/#{app.to_s}/GET /"])
-  end
-
-  def test_ignores_enduser
-    get_and_assert_ok '/'
-    assert_enduser_ignored(last_response)
-  end
-end

data/test/multiverse/suites/sinatra/nested_middleware_test.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-class MiddlewareApp < Sinatra::Base
-  get '/middle' do
-    "From the middlewarez"
-  end
-end
-
-class MainApp < Sinatra::Base
-  use MiddlewareApp
-
-  get '/main' do
-    "mainly done"
-  end
-end
-
-class NestedMiddlewareTest < Minitest::Test
-  include Rack::Test::Methods
-  include MultiverseHelpers
-
-  def app
-    MainApp
-  end
-
-  setup_and_teardown_agent
-
-  def test_inner_transaction
-    get '/main'
-    assert_metrics_recorded(["Controller/Sinatra/MainApp/#{name_for_route('main')}"])
-    assert_metrics_not_recorded(["Controller/Sinatra/MiddlewareApp/GET (unknown)"])
-  end
-
-  def test_outer_transaction
-    get '/middle'
-    assert_metrics_recorded(["Controller/Sinatra/MiddlewareApp/#{name_for_route('middle')}"])
-  end
-
-  def name_for_route path
-    if last_request.env.key? 'sinatra.route'
-      "GET /#{path}"
-    else
-      "GET #{path}"
-    end
-  end
-end