newrelic_rpm 3.9.4.245 → 3.9.5.251

data/test/multiverse/suites/sidekiq/Envfile

@@ -2,12 +2,19 @@ suite_condition("SideKiq requires MRI 1.9.3 or JRuby 1.6 in 1.9 mode") do
   RUBY_VERSION >= '1.9.3' || (RUBY_PLATFORM == 'java' && RUBY_VERSION >= '1.9')
 end
 
-gemfile <<-RB
-  gem 'json'
-  gem 'sidekiq', '~> 3.0.0'
-  gem 'rack'
-  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
-RB
+# Sidekiq 3.x does not support MRI 1.9.x
+if RUBY_VERSION >= '2.0.0' || (RUBY_PLATFORM == 'java')
+  gemfile <<-RB
+    gem 'json'
+    gem 'sidekiq', '~> 3.0.0'
+    gem 'rack'
+
+    # Work around for https://github.com/celluloid/celluloid/issues/457
+    gem 'celluloid', '0.15.2'
+
+    gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
+  RB
+end
 
 gemfile <<-RB
   gem 'json'

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

@@ -18,13 +18,14 @@ class SidekiqServer
   def run(file="test_worker.rb")
     @sidekiq.parse(["--require", File.join(File.dirname(__FILE__), file),
                     "--queue", "#{queue_name},1"])
-    Thread.new { @sidekiq.run }
+    @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"
-    @sidekiq.launcher.stop
+    puts "Trying to stop Sidekiq gracefully from #{$$}"
+    Process.kill("INT", $$)
+    @cli_thread.join
   end
 end

data/test/new_relic/agent/audit_logger_test.rb

@@ -31,6 +31,11 @@ class AuditLoggerTest < Minitest::Test
     @logger.stubs(:ensure_log_path).returns(@fakelog)
   end
 
+  def setup_fake_logger_with_failure(error)
+    setup_fake_logger
+    @logger.stubs(:enabled?).raises(error)
+  end
+
   def assert_log_contains_string(str)
     log_body = read_log_body
     assert(log_body.include?(str), "Expected log to contain string '#{str}'\nLog body was: #{log_body}")
@@ -133,4 +138,26 @@ class AuditLoggerTest < Minitest::Test
     end
     assert_log_contains_string('cachey-mccaherson')
   end
+
+  TRAPPABLE_ERRORS = [
+    StandardError.new,
+    SystemStackError.new,
+    SystemCallError.new("Syscalls FTW")
+  ]
+
+  TRAPPABLE_ERRORS.each do |error|
+    define_method("test_traps_#{error.class}") do
+      setup_fake_logger_with_failure(error)
+      @logger.log_request(@uri, @dummy_data, @marshaller)
+      assert_empty read_log_body
+    end
+  end
+
+  def test_allows_other_exceptions_through
+    setup_fake_logger_with_failure(Exception.new)
+    assert_raises(Exception) do
+      @logger.log_request(@uri, @dummy_data, @marshaller)
+    end
+  end
+
 end

data/test/new_relic/agent/error_collector_test.rb

@@ -237,10 +237,30 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   end
 
   def test_increment_error_count_record_summary_and_txn_metric
-    @error_collector.increment_error_count!(StandardError.new('Boo'),
-                                            :metric => 'Controller/class/method')
+    in_web_transaction('Controller/class/method') do
+      @error_collector.increment_error_count!(StandardError.new('Boo'))
+    end
+
+    assert_metrics_recorded(['Errors/all',
+                             'Errors/allWeb',
+                             'Errors/Controller/class/method'])
+  end
+
+  def test_increment_error_count_record_summary_and_txn_metric
+    in_background_transaction('OtherTransaction/AnotherFramework/Job/perform') do
+      @error_collector.increment_error_count!(StandardError.new('Boo'))
+    end
+
+    assert_metrics_recorded(['Errors/all',
+                             'Errors/allOther',
+                             'Errors/OtherTransaction/AnotherFramework/Job/perform'])
+  end
+
+  def test_icrement_error_count_summary_outside_transaction
+    @error_collector.increment_error_count!(StandardError.new('Boo'))
 
-    assert_metrics_recorded(['Errors/all', 'Errors/Controller/class/method'])
+    assert_metrics_recorded(['Errors/all'])
+    assert_metrics_not_recorded(['Errors/allWeb', 'Errors/allOther'])
   end
 
   def test_doesnt_increment_error_count_on_transaction_if_nameless
@@ -353,8 +373,9 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     end
     assert_metrics_recorded_exclusive(
       {
-        'Errors/all' => { :call_count => 1 },
-        'Errors/boo' => { :call_count => 1 }
+        'Errors/all'      => { :call_count => 1 },
+        'Errors/boo'      => { :call_count => 1 },
+        'Errors/allOther' => { :call_count => 1 }
       },
       :filter => /^Errors\//
     )

data/test/new_relic/agent/hostname_test.rb

@@ -8,30 +8,82 @@ require 'new_relic/agent/hostname'
 module NewRelic
   module Agent
     class HostnameTest < Minitest::Test
-      def test_get_returns_socket_hostname
+      def setup
         Socket.stubs(:gethostname).returns('Rivendell')
+      end
+
+      def test_get_returns_socket_hostname
         assert_equal 'Rivendell', NewRelic::Agent::Hostname.get
       end
 
       def test_get_uses_dyno_name_if_dyno_env_set_and_dyno_names_enabled
-        with_config(:use_heroku_dyno_names => true) do
-          Socket.stubs(:gethostname).returns('Rivendell')
-          ENV['DYNO'] = 'Imladris'
-
-          expected = 'Imladris'
-          assert_equal expected, NewRelic::Agent::Hostname.get
+        with_dyno_name('Imladris', :'heroku.use_dyno_names' => true) do
+          assert_equal 'Imladris', NewRelic::Agent::Hostname.get
         end
-      ensure
-        ENV.delete('DYNO')
       end
 
       def test_get_uses_socket_gethostname_if_dyno_env_set_and_dyno_names_disabled
-        with_config(:use_heroku_dyno_names => false) do
-          Socket.stubs(:gethostname).returns('Rivendell')
-          ENV['DYNO'] = 'Imladris'
+        with_dyno_name('Imladris', :'heroku.use_dyno_names' => false) do
+          assert_equal 'Rivendell', NewRelic::Agent::Hostname.get
+        end
+      end
+
+      def test_shortens_to_prefix_if_using_dyno_names_and_matches
+        with_dyno_name('Imladris.1', :'heroku.use_dyno_names' => true,
+                                     :'heroku.dyno_name_prefixes_to_shorten' => ['Imladris']) do
+          assert_equal 'Imladris.*', NewRelic::Agent::Hostname.get
+        end
+      end
+
+      def test_does_not_shorten_if_not_using_dyno_names
+        with_dyno_name('Imladris', :'heroku.use_dyno_names' => false,
+                                   :'heroku.dyno_name_prefixes_to_shorten' => ['Rivendell']) do
+          Socket.stubs(:gethostname).returns('Rivendell.1')
+          assert_equal 'Rivendell.1', NewRelic::Agent::Hostname.get
+        end
+      end
+
+      def test_only_shortens_if_matches_prefix_and_dot
+        with_dyno_name('ImladrisImladrisFakeout.1',
+                       :'heroku.use_dyno_names' => true,
+                       :'heroku.dyno_name_prefixes_to_shorten' => ['Imladris']) do
+          assert_equal 'ImladrisImladrisFakeout.1', NewRelic::Agent::Hostname.get
+        end
+      end
+
+      def test_shortens_to_prefixes_from_string
+        with_dyno_name('Imladris.1', :'heroku.use_dyno_names' => true,
+                                     :'heroku.dyno_name_prefixes_to_shorten' => 'Imladris') do
+          assert_equal 'Imladris.*', NewRelic::Agent::Hostname.get
+        end
+      end
+
+      def test_shortens_to_prefixes_from_string_allows_csv
+        with_dyno_name('Imladris.1', :'heroku.use_dyno_names' => true,
+                                     :'heroku.dyno_name_prefixes_to_shorten' => 'Rivendell,Imladris') do
+          assert_equal 'Imladris.*', NewRelic::Agent::Hostname.get
+        end
+      end
+
+      def test_shortens_to_prefixes_with_empty_string
+        with_dyno_name('Imladris.1', :'heroku.use_dyno_names' => true,
+                                     :'heroku.dyno_name_prefixes_to_shorten' => '') do
+          assert_equal 'Imladris.1', NewRelic::Agent::Hostname.get
+        end
+      end
+
+      def test_shortens_to_prefixes_with_unsupported_object
+        with_dyno_name('Imladris.1', :'heroku.use_dyno_names' => true,
+                                     :'heroku.dyno_name_prefixes_to_shorten' => Object.new) do
+          expects_logging(:warn, includes('Object'))
+          assert_equal 'Imladris.1', NewRelic::Agent::Hostname.get
+        end
+      end
 
-          expected = 'Rivendell'
-          assert_equal expected, NewRelic::Agent::Hostname.get
+      def with_dyno_name(dyno_name, config_options)
+        with_config(config_options) do
+          ENV['DYNO'] = dyno_name
+          yield
         end
       ensure
         ENV.delete('DYNO')

data/test/new_relic/agent/instrumentation/action_controller_subscriber_test.rb

@@ -206,19 +206,15 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minites
   end
 
   def test_applies_txn_name_rules
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => 'test',
-                                                  'replacement'      => 'taste')
-    NewRelic::Agent.instance.transaction_rules << rule
-    @subscriber.start('process_action.action_controller', :id, @entry_payload)
-    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    rule_specs = [{'match_expression' => 'test', 'replacement' => 'taste'}]
 
-    assert NewRelic::Agent.instance.stats_engine \
-      .lookup_stats('Controller/taste/index')
-    assert_nil NewRelic::Agent.instance.stats_engine \
-      .lookup_stats('Controller/test/index')
-  ensure
-    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
-                                             NewRelic::Agent::RulesEngine.new)
+    with_transaction_renaming_rules(rule_specs) do
+      @subscriber.start('process_action.action_controller', :id, @entry_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
+
+    assert_metrics_recorded(['Controller/taste/index'])
+    assert_metrics_not_recorded(['Controller/test/index'])
   end
 
   def test_record_queue_time_metrics

data/test/new_relic/agent/method_tracer/instance_methods/trace_execution_scoped_test.rb

@@ -11,32 +11,6 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     NewRelic::Agent.agent.stats_engine.clear_stats
   end
 
-  def test_get_stats_unscoped
-    fake_engine = mocked_object('stat_engine')
-    fake_engine.expects(:get_stats_no_scope).with('foob').returns('fakestats')
-    assert_equal 'fakestats', get_stats_unscoped('foob')
-  end
-
-  def test_get_stats_scoped_scoped_only
-    fake_engine = mocked_object('stat_engine')
-    fake_engine.expects(:get_stats).with('foob', true, true).returns('fakestats')
-    assert_equal 'fakestats', get_stats_scoped('foob', true)
-  end
-
-  def test_get_stats_scoped_no_scoped_only
-    fake_engine = mocked_object('stat_engine')
-    fake_engine.expects(:get_stats).with('foob', true, false).returns('fakestats')
-    assert_equal 'fakestats', get_stats_scoped('foob', false)
-  end
-
-  def test_stat_engine
-    assert_equal agent_instance.stats_engine, stat_engine
-  end
-
-  def test_agent_instance
-    assert_equal NewRelic::Agent.instance, agent_instance
-  end
-
   def test_metric_recording_outside_transaction
     trace_execution_scoped(['foo']) do
       # meh
@@ -120,7 +94,7 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     )
   end
 
-  def test_metric_recording_without_metric_option
+  def test_metric_recording_with_metric_option_false
     options = { :metric => false, :scoped_metric => false }
 
     in_transaction('outer') do
@@ -130,24 +104,12 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     end
 
     expected_values = { :call_count => 1 }
-    assert_metrics_recorded_exclusive(
-      'outer' => expected_values,
-      'bar'   => expected_values
-    )
-  end
-
-  def test_set_if_nil
-    h = {}
-    set_if_nil(h, :foo)
-    assert h[:foo]
-    h[:bar] = false
-    set_if_nil(h, :bar)
-    assert !h[:bar]
+    assert_metrics_recorded_exclusive('outer' => expected_values)
   end
 
   def test_log_errors_base
     ran = false
-    log_errors("name") do
+    NewRelic::Agent::MethodTracerHelpers.log_errors("name") do
       ran = true
     end
     assert ran, "should run the contents of the block"
@@ -155,7 +117,7 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
 
   def test_log_errors_with_return
     ran = false
-    return_val = log_errors('name') do
+    return_val = NewRelic::Agent::MethodTracerHelpers.log_errors('name') do
       ran = true
       'happy trees'
     end
@@ -169,7 +131,7 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
       includes("Caught exception in name."),
       instance_of(RuntimeError))
 
-    log_errors("name") do
+    NewRelic::Agent::MethodTracerHelpers.log_errors("name") do
       raise "should not propagate out of block"
     end
   end
@@ -177,9 +139,9 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
   def test_trace_execution_scoped_header
     state = NewRelic::Agent::TransactionState.tl_get
     stack = state.traced_method_stack
-    self.expects(:log_errors).with(:trace_execution_scoped_header).yields
+    NewRelic::Agent::MethodTracerHelpers.expects(:log_errors).with(:trace_execution_scoped_header).yields
     stack.expects(:push_frame).with(state, :method_tracer, 1.0)
-    trace_execution_scoped_header(state, 1.0)
+    NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, 1.0)
   end
 
   def test_trace_execution_scoped_calculates_exclusive_time

data/test/new_relic/agent/method_tracer_test.rb

@@ -93,7 +93,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
 
   def test_record_metrics_does_not_raise_outside_transaction
     state = NewRelic::Agent::TransactionState.tl_get
-    NewRelic::Agent::MethodTracer::TraceExecutionScoped.record_metrics(state, 'a', ['b'], 12, 10, :metric => true)
+    NewRelic::Agent::MethodTracerHelpers.record_metrics(state, 'a', ['b'], 12, 10, :metric => true)
 
     expected = { :call_count => 1, :total_call_time => 12, :total_exclusive_time => 10 }
     assert_metrics_recorded('a' => expected, 'b' => expected)
@@ -378,6 +378,57 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     assert_equal ['YY'], @scope_listener.scopes
   end
 
+  def test_add_method_tracer_module_double_inclusion
+    mod = Module.new { def traced_method; end }
+    cls = Class.new { include mod }
+
+    mod.module_eval do
+      include NewRelic::Agent::MethodTracer
+      add_method_tracer :traced_method
+    end
+
+    cls.new.traced_method
+  end
+
+  # This test validates that including the MethodTracer module does not pollute
+  # the host class with any additional helper methods that are not part of the
+  # official public API.
+  def test_only_adds_methods_to_host_that_are_part_of_public_api
+    host_class  = Class.new { include ::NewRelic::Agent::MethodTracer }
+    plain_class = Class.new
+
+    host_instance_methods  = host_class.new.methods
+    plain_instance_methods = plain_class.new.methods
+
+    added_methods = host_instance_methods - plain_instance_methods
+
+    public_api_methods = [
+      'trace_execution_unscoped',
+      'trace_execution_scoped',
+      'trace_method_execution',            # deprecated
+      'trace_method_execution_with_scope', # deprecated
+      'trace_method_execution_no_scope',   # deprecated
+      'get_stats_scoped',                  # deprecated
+      'get_stats_unscoped'                 # deprecated
+    ]
+
+    assert_equal(public_api_methods.sort, added_methods.map(&:to_s).sort)
+  end
+
+  def test_get_stats_unscoped
+    host_class = Class.new { include ::NewRelic::Agent::MethodTracer }
+    expected_stats = NewRelic::Agent.get_stats('foobar')
+    stats = host_class.new.get_stats_unscoped('foobar')
+    assert_same(expected_stats, stats)
+  end
+
+  def test_get_stats_scoped
+    host_class = Class.new { include ::NewRelic::Agent::MethodTracer }
+    expected_stats = NewRelic::Agent.get_stats('foobar', true)
+    stats = host_class.new.get_stats_scoped('foobar', false)
+    assert_same(expected_stats, stats)
+  end
+
   def trace_no_push_scope
     self.class.add_method_tracer :method_to_be_traced, 'X', :push_scope => false
     method_to_be_traced 1,2,3,true,nil

data/test/new_relic/agent/new_relic_service_test.rb

@@ -653,6 +653,82 @@ class NewRelicServiceTest < Minitest::Test
     refute @service.valid_to_marshal?({})
   end
 
+  def test_supportability_metrics_with_item_count
+    NewRelic::Agent.drop_buffered_data
+
+    payload = ['eggs', 'spam']
+    @http_handle.respond_to(:foobar, 'foobar')
+    @service.send(:invoke_remote, :foobar, payload, :item_count => 12)
+
+    expected_size_bytes = @service.marshaller.dump(payload).size
+    expected_values = {
+      :call_count           => 1,
+      :total_call_time      => expected_size_bytes,
+      :total_exclusive_time => 12
+    }
+
+    assert_metrics_recorded(
+      'Supportability/invoke_remote'                  => { :call_count => 1 },
+      'Supportability/invoke_remote/foobar'           => { :call_count => 1 },
+      'Supportability/invoke_remote_serialize'        => { :call_count => 1 },
+      'Supportability/invoke_remote_serialize/foobar' => { :call_count => 1},
+      'Supportability/invoke_remote_size'             => expected_values,
+      'Supportability/invoke_remote_size/foobar'      => expected_values
+    )
+  end
+
+  def test_supportability_metrics_without_item_count
+    NewRelic::Agent.drop_buffered_data
+
+    payload = ['eggs', 'spam']
+    @http_handle.respond_to(:foobar, 'foobar')
+    @service.send(:invoke_remote, :foobar, payload)
+
+    expected_size_bytes = @service.marshaller.dump(payload).size
+    expected_values = {
+      :call_count           => 1,
+      :total_call_time      => expected_size_bytes,
+      :total_exclusive_time => 0
+    }
+
+    assert_metrics_recorded(
+      'Supportability/invoke_remote'                  => { :call_count => 1 },
+      'Supportability/invoke_remote/foobar'           => { :call_count => 1 },
+      'Supportability/invoke_remote_serialize'        => { :call_count => 1 },
+      'Supportability/invoke_remote_serialize/foobar' => { :call_count => 1},
+      'Supportability/invoke_remote_size'             => expected_values,
+      'Supportability/invoke_remote_size/foobar'      => expected_values
+    )
+  end
+
+  def test_supportability_metrics_with_serialization_failure
+    NewRelic::Agent.drop_buffered_data
+
+    payload = ['eggs', 'spam']
+    @http_handle.respond_to(:foobar, 'foobar')
+    @service.marshaller.stubs(:dump).raises(StandardError.new)
+
+    assert_raises(NewRelic::Agent::SerializationError) do
+      @service.send(:invoke_remote, :foobar, payload)
+    end
+
+    expected_values = { :call_count => 1 }
+
+    assert_metrics_recorded(
+      'Supportability/invoke_remote'                => expected_values,
+      'Supportability/invoke_remote/foobar'         => expected_values,
+      'Supportability/serialization_failure'        => expected_values,
+      'Supportability/serialization_failure/foobar' => expected_values
+    )
+
+    assert_metrics_not_recorded([
+      'Supportability/invoke_remote_serialize',
+      'Supportability/invoke_remote_serialize/foobar',
+      'Supportability/invoke_remote_size',
+      'Supportability/invoke_remote_size/foobar'
+    ])
+  end
+
   def build_stats_hash(items={})
     hash = NewRelic::Agent::StatsHash.new
     items.each do |key, value|