newrelic_rpm 4.1.0.333 → 4.2.0.334

data/test/multiverse/suites/sequel/sequel_helpers.rb

@@ -1,62 +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.
-
-module SequelHelpers
-  def setup
-    super
-
-    DB.extension :newrelic_instrumentation
-
-    NewRelic::Agent.drop_buffered_data
-  end
-
-  def teardown
-    super
-
-    NewRelic::Agent.shutdown
-  end
-	#
-  # Helpers
-  #
-
-  # Pattern to match the column headers of a Sqlite explain plan
-  SQLITE_EXPLAIN_PLAN_COLUMNS_RE =
-    %r{\|addr\s*\|opcode\s*\|p1\s*\|p2\s*\|p3\s*\|p4\s*\|p5\s*\|comment\s*\|}
-
-  # This is particular to sqlite plans currently. To abstract it up, we'd need to
-  # be able to specify a flavor (e.g., :sqlite, :postgres, :mysql, etc.)
-  def assert_node_has_explain_plan( node, msg=nil )
-    msg = "Expected #{node.inspect} to have an explain plan"
-    assert_block( msg ) { node.params[:explain_plan].join =~ SQLITE_EXPLAIN_PLAN_COLUMNS_RE }
-  end
-
-  def last_node_for(options={})
-      in_transaction('sandwiches/index') do
-        yield
-      end
-      sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-      sample.prepare_to_send!
-      last_node(sample)
-  end
-
-  def last_node(txn_sample)
-    l_node = nil
-    txn_sample.root_node.each_node do |node|
-      l_node = node
-    end
-    l_node
-  end
-
-  def product_name
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-      "JDBC"
-    else
-      "SQLite"
-    end
-  end
-
-  def assert_datastore_metrics_recorded_exclusive(metrics, options = {})
-    assert_metrics_recorded_exclusive(metrics, {:filter => /^Datastores/}.update(options))
-  end
-end

data/test/multiverse/suites/sequel/sequel_plugin_test.rb

@@ -1,230 +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 File.join(File.dirname(__FILE__), 'database.rb')
-require File.join(File.dirname(__FILE__), 'sequel_helpers.rb')
-
-if Sequel.const_defined?( :MAJOR ) &&
-      ( Sequel::MAJOR > 3 ||
-        Sequel::MAJOR == 3 && Sequel::MINOR >= 37 )
-
-require 'newrelic_rpm'
-
-class SequelPluginTest < Minitest::Test
-  include SequelHelpers
-
-  def expected_metrics_for_operation(operation)
-    [
-      ["Datastore/statement/#{product_name}/Post/#{operation}", "dummy"],
-      "Datastore/statement/#{product_name}/Post/#{operation}",
-      "Datastore/operation/#{product_name}/#{operation}",
-      "Datastore/#{product_name}/allWeb",
-      "Datastore/allWeb",
-      "Datastore/#{product_name}/all",
-      "Datastore/all",
-      "dummy",
-      "Apdex"
-    ]
-  end
-
-  def test_sequel_model_instrumentation_is_loaded
-    assert Post.respond_to?( :trace_execution_scoped )
-  end
-
-  def test_model_enumerator_generates_metrics
-    in_web_transaction { Post.all }
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:all))
-  end
-
-  def test_model_index_operator_generates_metrics
-    in_web_transaction { Post[11] }
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:get))
-  end
-
-  def test_model_create_method_generates_metrics
-    in_web_transaction do
-      Post.create( :title => 'The Thing', :content => 'A wicked short story.' )
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:create))
-  end
-
-  def test_model_update_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'All The Things', :content => 'A story about beans.' )
-      end
-
-      post.update( :title => 'A Lot of the Things' )
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:update))
-  end
-
-  def test_model_update_all_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'All The Things', :content => 'A nicer story than yours.' )
-      end
-
-      post.update_all( :title => 'A Whole Hell of a Lot of the Things' )
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:update_all))
-  end
-
-  def test_model_update_except_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'All The Things', :content => 'A story.' )
-      end
-
-      post.update_except( {:title => 'A Bit More of the Things'} )
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:update_except))
-  end
-
-  def test_model_update_fields_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'All The Things', :content => 'A venal short story.' )
-      end
-
-      post.update_fields( {:title => 'A Plethora of Things'}, [:title] )
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:update_fields))
-  end
-
-  def test_model_update_only_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'All The Things', :content => 'A meandering short story.' )
-      end
-
-      post.update_only( {:title => 'A Lot of the Things'}, :title )
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:update_only))
-  end
-
-  def test_model_save_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.new( :title => 'An Endless Lot Full of Things',
-                  :content => 'A lingering long story.' )
-      end
-
-      post.save
-    end
-
-   assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:save))
-  end
-
-  def test_model_delete_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'All The Things', :content => 'A nice short story.' )
-      end
-
-      post.delete
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:delete))
-  end
-
-  def test_model_destroy_method_generates_metrics
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'Most of the Things', :content => 'Another short story.' )
-      end
-
-      post.destroy
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:destroy))
-  end
-
-  def test_model_destroy_uses_the_class_name_for_the_metric
-    in_web_transaction do
-      post = NewRelic::Agent.disable_all_tracing do
-        Post.create( :title => 'Some of the Things', :content => 'A shorter story.' )
-      end
-
-      post.destroy
-    end
-
-    assert_datastore_metrics_recorded_exclusive(expected_metrics_for_operation(:destroy))
-  end
-
-  def test_slow_queries_get_an_explain_plan
-    with_config( :'transaction_tracer.explain_threshold' => -0.01,
-                 :'transaction_tracer.record_sql' => 'raw' ) do
-      node = last_node_for do
-        Post[11]
-      end
-      assert_match %r{select \* from `posts` where `id` = 11}i, node.params[:sql]
-      assert_node_has_explain_plan( node )
-    end
-  end
-
-  def test_sql_is_recorded_in_tt_for_non_select
-    with_config(:'transaction_tracer.record_sql' => 'raw') do
-      node = last_node_for do
-        Post.create(:title => 'title', :content => 'content')
-      end
-      assert_match %r{insert into `posts` \([^\)]*\) values \([^\)]*\)}i, node.params[:sql]
-    end
-  end
-
-  def test_no_explain_plans_with_single_threaded_connection
-    connect_opts = DB.opts
-    single_threaded_db = Sequel.connect(connect_opts.merge(:single_threaded => true))
-    create_tables(single_threaded_db)
-    model_class = Class.new(Sequel::Model(single_threaded_db[:posts]))
-
-    with_config(:'transaction_tracer.explain_threshold' => -0.01,
-                :'transaction_tracer.record_sql' => 'raw') do
-      node = last_node_for do
-        model_class[11]
-      end
-      assert_match %r{select \* from `posts` where `id` = 11}i, node.params[:sql]
-      assert_equal([], node.params[:explain_plan], "Should not capture explain plan with single-threaded connection pool")
-    end
-  end
-
-  def test_queries_can_get_explain_plan_with_obfuscated_sql
-    config = {
-      :'transaction_tracer.explain_threshold' => -0.01,
-      :'transaction_tracer.record_sql' => 'obfuscated'
-    }
-    with_config(config) do
-      node = last_node_for(:record_sql => :obfuscated) do
-        Post[11]
-      end
-      assert_match %r{select \* from `posts` where `id` = \?}i, node.params[:sql]
-      assert_node_has_explain_plan( node )
-    end
-  end
-
-  def test_notices_sql_with_proper_metric_name_for_select
-    config = {
-      :'transaction_tracer.explain_threshold' => -0.01,
-      :'transaction_tracer.record_sql' => 'obfuscated'
-    }
-    with_config(config) do
-      in_web_transaction { Post.all }
-      expected_metric_name = "Datastore/operation/#{product_name}/select"
-      recorded_metric_names = NewRelic::Agent.agent.sql_sampler.sql_traces.values.map(&:database_metric_name)
-      assert recorded_metric_names.include? expected_metric_name
-    end
-  end
-end
-
-else
-  puts "Skipping tests in #{__FILE__} because unsupported Sequel version"
-end

data/test/multiverse/suites/sequel/sequel_safety_test.rb

@@ -1,30 +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-1123
-# https://support.newrelic.com/tickets/42515
-
-require File.join(File.dirname(__FILE__), 'database.rb')
-
-class SequelSafetyTest < Minitest::Test
-
-  def test_it_doesnt_blow_up
-    require 'newrelic_rpm'
-
-    u = User.create( :login => 'jrandom', :firstname => 'J. Random', :lastname => 'Hacquer' )
-    assert u.is_a?( User ), "#{u} isn't a User"
-  end
-
-  # The oldest version of Sequel that we test against does not define a VERSION
-  # constant, or the in_transaction? method, so skip this test for that version.
-  if DB.respond_to?(:in_transaction?)
-    def test_should_not_clobber_in_transaction
-      require 'newrelic_rpm'
-
-      DB.transaction do
-        assert_equal(true, DB.in_transaction?)
-      end
-    end
-  end
-end

data/test/multiverse/suites/sidekiq/Envfile

@@ -1,43 +0,0 @@
-gemfile <<-RB
-  gem 'json'
-  gem 'sidekiq', '~> 3.4.2'
-  gem 'rack'
-
-  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
-RB
-
-gemfile <<-RB
-  gem 'json'
-  gem 'sidekiq', '~> 4.0.0'
-  gem 'rack'
-  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
-RB
-
-if RUBY_VERSION < '2.4.0' && RUBY_PLATFORM != 'java'
-  # We skip testing Sidekiq 3.5.3 on JRuby due to an error in Sidekiq's shutdown:
-  # https://github.com/mperham/sidekiq/issues/2703
-  gemfile <<-RB
-    gem 'json'
-    gem 'sidekiq', '~> 3.5.3'
-    gem 'rack'
-    gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
-  RB
-end
-
-gemfile <<-RB
-  gem 'json'
-  gem 'sidekiq', '~> 2.17.8'
-  gem 'rack'
-  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
-RB
-
-gemfile <<-RB
-  # Almost oldest supported version
-  gem 'json'
-  gem 'sidekiq', '~> 2.9.0'
-  gem 'timers', '~> 1.1.0'
-  gem 'rack'
-  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
-RB
-
-# vim: ft=ruby

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

@@ -1,16 +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.
-
-module Sidekiq
-  class CLI
-    def exit(*args)
-      # No-op Sidekiq's exit since we don't want it shutting us down and eating
-      # our exit code
-    end
-  end
-end
-
-if defined?(SidekiqServer)
-  SidekiqServer.instance.stop
-end

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

@@ -1,19 +0,0 @@
----
-development:
-  error_collector:
-    enabled: true
-  apdex_t: 0.5
-  ssl: false
-  monitor_mode: true
-  license_key: bootstrap_newrelic_admin_license_key_000
-  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
-  log_file_path: log

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