newrelic_rpm 3.6.6.147 → 3.6.7.152

data/test/new_relic/agent/configuration/environment_source_test.rb

@@ -11,6 +11,7 @@ module NewRelic::Agent::Configuration
     def setup
       @original_env = {}
       @original_env.replace(ENV)
+      @environment_source = EnvironmentSource.new
     end
 
     def teardown
@@ -24,7 +25,10 @@ module NewRelic::Agent::Configuration
       assert_applied_string 'NEW_RELIC_APP_NAME', 'app_name'
       assert_applied_string 'NEWRELIC_APP_NAME', 'app_name'
       assert_applied_string 'NEW_RELIC_HOST', 'host'
-      assert_applied_string 'NEW_RELIC_PORT', 'port'
+    end
+
+    def test_environment_fixnums_are_applied
+      assert_applied_fixnum 'NEW_RELIC_PORT', 'port'
     end
 
     def test_environment_symbols_are_applied
@@ -37,21 +41,21 @@ module NewRelic::Agent::Configuration
     %w| NEWRELIC_ENABLE NEWRELIC_ENABLED NEW_RELIC_ENABLE NEW_RELIC_ENABLED |.each do |var|
       define_method("test_environment_booleans_truths_are_applied_to_#{var}") do
         ENV[var] = 'true'
-        assert EnvironmentSource.new[:agent_enabled]
+        assert EnvironmentSource.new[:enabled]
         ENV[var] = 'on'
-        assert EnvironmentSource.new[:agent_enabled]
+        assert EnvironmentSource.new[:enabled]
         ENV[var] = 'yes'
-        assert EnvironmentSource.new[:agent_enabled]
+        assert EnvironmentSource.new[:enabled]
         ENV.delete(var)
       end
 
       define_method("test_environment_booleans_falsehoods_are_applied_to_#{var}") do
         ENV[var] = 'false'
-        assert !EnvironmentSource.new[:agent_enabled]
+        assert !EnvironmentSource.new[:enabled]
         ENV[var] = 'off'
-        assert !EnvironmentSource.new[:agent_enabled]
+        assert !EnvironmentSource.new[:enabled]
         ENV[var] = 'no'
-        assert !EnvironmentSource.new[:agent_enabled]
+        assert !EnvironmentSource.new[:enabled]
         ENV.delete(var)
       end
     end
@@ -92,6 +96,63 @@ module NewRelic::Agent::Configuration
       assert_equal 'STDOUT', source[:log_file_path]
     end
 
+    def test_set_values_from_new_relic_environment_variables
+      keys = %w(NEW_RELIC_LICENSE_KEY NEWRELIC_CONFIG_PATH)
+      keys.each { |key| ENV[key] = 'skywizards' }
+
+      expected_source = EnvironmentSource.new
+
+      [:license_key, :config_path].each do |key|
+        assert_equal 'skywizards', expected_source[key]
+      end
+    end
+
+    def test_set_value_from_environment_variable
+      ENV['NEW_RELIC_LICENSE_KEY'] = 'super rad'
+      @environment_source.set_value_from_environment_variable('NEW_RELIC_LICENSE_KEY')
+      assert_equal @environment_source[:license_key], 'super rad'
+    end
+
+    def test_set_key_by_type_uses_the_default_type
+      ENV['NEW_RELIC_TEST'] = 'true'
+      @environment_source.set_key_by_type(:enabled, 'NEW_RELIC_TEST')
+      assert_equal true, @environment_source[:enabled]
+    end
+
+    def test_set_key_with_new_relic_prefix
+      assert_applied_string('NEW_RELIC_LICENSE_KEY', :license_key)
+    end
+
+    def test_set_key_with_newrelic_prefix
+      assert_applied_string('NEWRELIC_LICENSE_KEY', :license_key)
+    end
+
+    def test_does_not_set_key_without_new_relic_related_prefix
+      ENV['CONFIG_PATH'] = 'boom'
+      assert_not_equal 'boom', EnvironmentSource.new[:config_path]
+    end
+
+    def test_convert_environment_key_to_config_key
+      result = @environment_source.convert_environment_key_to_config_key('NEW_RELIC_IS_RAD')
+      assert_equal :is_rad, result
+    end
+
+    def test_convert_environment_key_to_config_key_respects_aliases
+      assert_applied_boolean('NEWRELIC_ENABLE', :enabled)
+    end
+
+    def test_convert_environment_key_to_config_key_allows_underscores_as_dots
+      assert_applied_string('NEW_RELIC_AUDIT_LOG_PATH', :'audit_log.path')
+    end
+
+    def test_collect_new_relic_environment_variable_keys
+      keys = %w(NEW_RELIC_IS_RAD NEWRELIC_IS_MAGIC)
+      keys.each { |key| ENV[key] = 'true' }
+
+      result = @environment_source.collect_new_relic_environment_variable_keys
+      assert_equal keys, result
+    end
+
     def assert_applied_string(env_var, config_var)
       ENV[env_var] = 'test value'
       assert_equal 'test value', EnvironmentSource.new[config_var.to_sym]
@@ -103,5 +164,18 @@ module NewRelic::Agent::Configuration
       assert_equal :'test value', EnvironmentSource.new[config_var.to_sym]
       ENV.delete(env_var)
     end
+
+    def assert_applied_fixnum(env_var, config_var)
+      ENV[env_var] = '3000'
+      assert_equal 3000, EnvironmentSource.new[config_var.to_sym]
+      ENV.delete(env_var)
+    end
+
+    def assert_applied_boolean(env_var, config_var)
+      ENV[env_var] = 'true'
+      assert_equal true, EnvironmentSource.new[config_var.to_sym]
+      ENV.delete(env_var)
+    end
+
   end
 end

data/test/new_relic/agent/configuration/manager_test.rb

@@ -72,6 +72,21 @@ module NewRelic::Agent::Configuration
       @manager.remove_config(source)
     end
 
+    def test_manager_resolves_nested_procs_from_default_source
+      source = {
+        :foo    => Proc.new { self[:bar] },
+        :bar    => Proc.new { self[:baz] },
+        :baz    => Proc.new { 'Russian Nesting Dolls!' }
+      }
+      @manager.apply_config(source)
+
+      source.keys.each do |key|
+        assert_equal 'Russian Nesting Dolls!', @manager[key]
+      end
+
+      @manager.remove_config(source)
+    end
+
     def test_should_not_apply_removed_sources
       test_source = TestSource.new
       @manager.apply_config(test_source)
@@ -138,7 +153,7 @@ module NewRelic::Agent::Configuration
     end
 
     def test_config_masks_thread_profiler
-      supported = NewRelic::Agent::ThreadProfiler.is_supported?
+      supported = NewRelic::Agent::Commands::ThreadProfiler.is_supported?
       reported_config = @manager.to_collector_hash
 
       if supported

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -41,9 +41,7 @@ module NewRelic::Agent
 
       NewRelic::Agent.config.apply_config( @config )
       @monitor.register_event_listeners
-      NewRelic::Agent::TransactionInfo.get.guid = TRANSACTION_GUID
-
-      # NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new( {:log_level => 'debug'}, '', Logger.new($stderr) )
+      NewRelic::Agent::TransactionState.get.request_guid = TRANSACTION_GUID
     end
 
     def teardown
@@ -66,7 +64,7 @@ module NewRelic::Agent
     end
 
     def test_encodes_transaction_name
-      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
+      NewRelic::Agent::TransactionState.any_instance.stubs(:timings).returns(stub(
           :transaction_name => "\"'goo",
           :queue_time_in_seconds => QUEUE_TIME,
           :app_time_in_seconds => APP_TIME))
@@ -228,7 +226,7 @@ module NewRelic::Agent
     end
 
     def with_default_timings
-      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
+      NewRelic::Agent::TransactionState.any_instance.stubs(:timings).returns(stub(
           :transaction_name => TRANSACTION_NAME,
           :queue_time_in_seconds => QUEUE_TIME,
           :app_time_in_seconds => APP_TIME))

data/test/new_relic/agent/error_collector_test.rb

@@ -301,6 +301,20 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert err.message.include?("Ruby agent internal error")
   end
 
+  def test_blamed_metric_from_options
+    assert_equal "Errors/boo", @error_collector.blamed_metric_name(:metric => "boo")
+  end
+
+  def test_blamed_metric_from_transaction
+    NewRelic::Agent::TransactionState.get.transaction = stub(:name => "Controller/foo/bar")
+    assert_equal "Errors/Controller/foo/bar", @error_collector.blamed_metric_name({})
+  end
+
+  def test_blamed_metric_with_no_transaction
+    NewRelic::Agent::TransactionState.get.transaction = nil
+    assert_nil @error_collector.blamed_metric_name({})
+  end
+
   private
 
   def expects_error_count_increase(increase)

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

@@ -132,7 +132,7 @@ class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Test::U
     @subscriber.start('process_action.action_controller', :id, @entry_payload)
     @subscriber.finish('process_action.action_controller', :id, @exit_payload)
 
-    assert NewRelic::Agent::TransactionInfo.get.ignore_end_user?
+    assert NewRelic::Agent::TransactionState.get.request_ignore_enduser
   end
 
   def test_record_busy_time

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

@@ -23,6 +23,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   def setup
     super
     NewRelic::Agent.manual_start
+    ActiveRecord::Base.establish_connection unless ActiveRecord::Base.connection.active?
     ActiveRecordFixtures.setup
     NewRelic::Agent.instance.transaction_sampler.reset!
     NewRelic::Agent.instance.stats_engine.clear_stats
@@ -33,8 +34,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def teardown
     super
-    NewRelic::Agent::TransactionInfo.reset
-    Thread::current[:newrelic_scope_name] = nil
+    NewRelic::Agent::TransactionState.reset
     NewRelic::Agent.shutdown
   end
 
@@ -299,7 +299,6 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def test_direct_sql
     assert_nil NewRelic::Agent::Transaction.current
-    assert_nil NewRelic::Agent.instance.stats_engine.scope_name
     assert_equal 0, NewRelic::Agent.instance.stats_engine.metrics.size, NewRelic::Agent.instance.stats_engine.metrics.inspect
 
     expected_metrics = %W[

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

@@ -31,24 +31,20 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
   end
 
   def test_records_metrics_for_simple_find
-    t1 = Time.now
-    t0 = t1 - 2
-    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+    freeze_time
 
-    metric_name = 'ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
+    simulate_query(2)
 
-    metric = @stats_engine.lookup_stats(metric_name)
-    assert_equal(1, metric.call_count)
-    assert_equal(2.0, metric.total_call_time)
+    metric_name = 'ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
+    assert_metrics_recorded(
+      metric_name => { :call_count => 1, :total_call_time => 2.0 }
+    )
   end
 
   def test_records_scoped_metrics
-    t1 = Time.now
-    t0 = t1 - 2
+    freeze_time
 
-    in_transaction('test_txn') do
-      @subscriber.call('sql.active_record', t0, t1, :id, @params)
-    end
+    in_transaction('test_txn') { simulate_query(2) }
 
     metric_name = 'ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
     assert_metrics_recorded(
@@ -57,24 +53,18 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
   end
 
   def test_records_nothing_if_tracing_disabled
-    t1 = Time.now
-    t0 = t1 - 2
+    freeze_time
 
-    NewRelic::Agent.disable_all_tracing do
-      @subscriber.call('sql.active_record', t0, t1, :id, @params)
-    end
+    NewRelic::Agent.disable_all_tracing { simulate_query(2) }
 
     metric_name = 'ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
     assert_metrics_not_recorded([metric_name])
   end
 
   def test_records_rollup_metrics
-    t1 = Time.now
-    t0 = t1 - 2
+    freeze_time
 
-    in_web_transaction do
-      @subscriber.call('sql.active_record', t0, t1, :id, @params)
-    end
+    in_web_transaction { simulate_query(2) }
 
     assert_metrics_recorded(
       'ActiveRecord/find' => { :call_count => 1, :total_call_time => 2 },
@@ -83,10 +73,9 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
   end
 
   def test_records_remote_service_metric
-    t1 = Time.now
-    t0 = t1 - 2
+    freeze_time
 
-    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+    simulate_query(2)
 
     assert_metrics_recorded(
       'RemoteService/sql/mysql/server' => { :call_count => 1, :total_call_time => 2.0 }
@@ -94,8 +83,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
   end
 
   def test_creates_txn_segment
-    t1 = Time.now
-    t0 = t1 - 2
+    freeze_time
 
     NewRelic::Agent.manual_start
     @stats_engine.start_transaction
@@ -103,7 +91,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
     sampler.notice_first_scope_push(Time.now.to_f)
     sampler.notice_transaction('/path', {})
     sampler.notice_push_scope('Controller/sandwiches/index')
-    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+    simulate_query(2)
     sampler.notice_pop_scope('Controller/sandwiches/index')
     sampler.notice_scope_empty(stub('txn', :name => '/path', :custom_parameters => {}))
 
@@ -121,15 +109,25 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
     NewRelic::Agent.manual_start
     sampler = NewRelic::Agent.instance.sql_sampler
     sampler.notice_first_scope_push nil
-    t1 = Time.now
-    t0 = t1 - 2
+    freeze_time
 
-    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+    simulate_query(2)
 
     assert_equal 'SELECT * FROM sandwiches', sampler.transaction_data.sql_data[0].sql
   ensure
     NewRelic::Agent.shutdown
   end
+
+  def test_should_not_raise_due_to_an_exception_during_instrumentation_callback
+    @subscriber.stubs(:record_metrics).raises(StandardError)
+    assert_nothing_raised { simulate_query }
+  end
+
+  def simulate_query(duration=nil)
+    @subscriber.start('sql.active_record', :id, @params)
+    advance_time(duration) if duration
+    @subscriber.finish('sql.active_record', :id, @params)
+  end
 end
 
 else

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

@@ -7,6 +7,18 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Test::Un
   require 'new_relic/agent/instrumentation/controller_instrumentation'
   class TestObject
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    def public_transaction(*args); end
+
+    protected
+    def protected_transaction(*args); end
+
+    private
+    def private_transaction(*args); end
+
+    add_transaction_tracer :public_transaction
+    add_transaction_tracer :protected_transaction
+    add_transaction_tracer :private_transaction
   end
 
   def setup
@@ -94,4 +106,14 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Test::Un
     result = @txn_namer.path_name(:name => "perform", :class_name => 'Resque')
     assert_equal("Resque/perform", result)
   end
+
+  def test_add_transaction_tracer_should_not_double_instrument
+    TestObject.expects(:alias_method).never
+    TestObject.class_eval do
+      add_transaction_tracer :public_transaction
+      add_transaction_tracer :protected_transaction
+      add_transaction_tracer :private_transaction
+    end
+    obj = TestObject.new
+  end
 end

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

@@ -3,9 +3,9 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
-class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest < Test::Unit::TestCase
+class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Test::Unit::TestCase
   require 'new_relic/agent/method_tracer'
-  include NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped
+  include NewRelic::Agent::MethodTracer::TraceExecutionScoped
 
   def setup
     NewRelic::Agent.agent.stats_engine.clear_stats

data/test/new_relic/agent/method_tracer_test.rb

@@ -62,7 +62,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   attr_reader :stats_engine
 
   def setup
-    Thread::current[:newrelic_scope_stack] = nil
+    NewRelic::Agent::TransactionState.clear
 
     NewRelic::Agent.manual_start
     @stats_engine = NewRelic::Agent.instance.stats_engine
@@ -94,7 +94,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
 
   def test_record_metrics_does_not_raise_outside_transaction
     assert_nothing_raised do
-      NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped.record_metrics('a', ['b'], 12, 10, :metric => true)
+      NewRelic::Agent::MethodTracer::TraceExecutionScoped.record_metrics('a', ['b'], 12, 10, :metric => true)
     end
     expected = { :call_count => 1, :total_call_time => 12, :total_exclusive_time => 10 }
     assert_metrics_recorded('a' => expected, 'b' => expected)

data/test/new_relic/agent/new_relic_service_test.rb

@@ -3,7 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
-require 'new_relic/agent/thread_profiler'
+require 'new_relic/agent/commands/thread_profiler'
 
 # Tests of HTTP Keep Alive implementation that require a different setup and
 # set of mocks.
@@ -108,42 +108,6 @@ class NewRelicServiceTest < Test::Unit::TestCase
     assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'cert', 'cacert.pem')), @service.cert_file_path
   end
 
-  # This test does not actually use the ruby agent in any way - it's
-  # testing that the CA file we ship actually validates our server's
-  # certificate.
-  def test_cert_file
-    if internet_connection?
-      require 'socket'
-      require 'openssl'
-
-      s   = TCPSocket.new 'collector.newrelic.com', 443
-      ctx = OpenSSL::SSL::SSLContext.new
-      ctx.ca_file = @service.cert_file_path
-      ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      s   = OpenSSL::SSL::SSLSocket.new s, ctx
-      s.connect
-    # should not raise an error
-    end
-  end
-
-  # see above, but for staging, as well. This allows us to test new
-  # certificates in a non-customer-facing place before setting them
-  # live.
-  def test_staging_cert_file
-    if internet_connection?
-      require 'socket'
-      require 'openssl'
-
-      s   = TCPSocket.new 'staging-collector.newrelic.com', 443
-      ctx = OpenSSL::SSL::SSLContext.new
-      ctx.ca_file = @service.cert_file_path
-      ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      s   = OpenSSL::SSL::SSLSocket.new s, ctx
-      s.connect
-      # should not raise an error
-    end
-  end
-
   def test_initialize_uses_correct_license_key_settings
     with_config(:license_key => 'abcde') do
       service = NewRelic::Agent::NewRelicService.new
@@ -269,12 +233,11 @@ class NewRelicServiceTest < Test::Unit::TestCase
     assert_equal 'some analytic events', response
   end
 
-
-# Thread profiling only available in certain versions
-if NewRelic::Agent::ThreadProfiler.is_supported?
+  # Although thread profiling is only available in some circumstances, the
+  # service communication doesn't care about that at all
   def test_profile_data
     @http_handle.respond_to(:profile_data, 'profile' => 123)
-    response = @service.profile_data(NewRelic::Agent::ThreadProfile.new(0, 0, 0, true))
+    response = @service.profile_data([])
     assert_equal({ "profile" => 123 }, response)
   end
 
@@ -296,17 +259,10 @@ if NewRelic::Agent::ThreadProfiler.is_supported?
 
   def test_agent_command_results
     @http_handle.respond_to(:agent_command_results, {})
-    response = @service.agent_command_results(4200)
+    response = @service.agent_command_results({'1' => {}})
     assert_equal({}, response)
   end
 
-  def test_agent_command_results_with_errors
-    @http_handle.respond_to(:agent_command_results, [123])
-    response = @service.agent_command_results(4200, 'Boo!')
-    assert_equal [123], response
-  end
-end
-
   def test_request_timeout
     with_config(:timeout => 600) do
       service = NewRelic::Agent::NewRelicService.new('abcdef', @server)