newrelic_rpm 3.6.0.74.beta → 3.6.0.78

data/test/new_relic/agent/agent/connect_test.rb

@@ -82,18 +82,15 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     handle_license_error(error)
   end
 
-  def test_environment_for_connect_positive
-    fake_env = stub('local_env', :discovered_dispatcher => nil)
-    fake_env.expects(:snapshot).returns("snapshot")
-    NewRelic::Control.instance.expects(:local_env).at_least_once.returns(fake_env)
-    with_config(:send_environment_info => true) do
-      assert_equal 'snapshot', environment_for_connect
-    end
+  def test_connect_settings_have_environment_report
+    assert NewRelic::Agent.agent.connect_settings[:environment].detect{ |(k, v)|
+      k == 'Gems'
+    }, "expected connect_settings to include gems from environment"
   end
 
   def test_environment_for_connect_negative
     with_config(:send_environment_info => false) do
-      assert_equal [], environment_for_connect
+      assert_equal [], NewRelic::Agent.agent.connect_settings[:environment]
     end
   end
 

data/test/new_relic/agent/agent/start_test.rb

@@ -18,7 +18,9 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_already_started_positive
-    ::Logger.any_instance.expects(:error).with("Agent Started Already!")
+    dummy_logger = mock
+    dummy_logger.expects(:error).with("Agent Started Already!")
+    NewRelic::Agent.stubs(:logger).returns(dummy_logger)
     self.expects(:started?).returns(true)
     assert already_started?, "should have already started"
   end

data/test/new_relic/agent/agent_logger_test.rb

@@ -4,6 +4,7 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require 'new_relic/agent/agent_logger'
+require 'new_relic/agent/null_logger'
 
 class AgentLoggerTest < Test::Unit::TestCase
   def setup
@@ -67,18 +68,17 @@ class AgentLoggerTest < Test::Unit::TestCase
   end
 
   def test_wont_log_if_agent_not_enabled
-    ::Logger.stubs(:new).with("/dev/null").returns(stub(:level=)).at_least_once
-
+    null_logger = NewRelic::Agent::NullLogger.new
+    NewRelic::Agent::NullLogger.expects(:new).returns(null_logger)
     @config[:agent_enabled] = false
     logger = NewRelic::Agent::AgentLogger.new(@config)
+    assert_nothing_raised do
+      logger.warn('hi there')
+    end
   end
 
-  def test_logs_to_nul_if_dev_null_not_there
-    File.stubs(:exists?).with("/dev/null").returns(false)
-    File.stubs(:exists?).with("NUL").returns(true)
-
-    ::Logger.stubs(:new).with("NUL").returns(stub(:level=)).once
-
+  def test_does_not_touch_dev_null
+    Logger.expects(:new).with('/dev/null').never
     @config[:agent_enabled] = false
     logger = NewRelic::Agent::AgentLogger.new(@config)
   end

data/test/new_relic/agent/agent_test.rb

@@ -69,12 +69,6 @@ module NewRelic
         @agent.instance_eval { transmit_data }
       end
 
-      def test_transmit_data_should_not_close_db_connections_if_forked
-        NewRelic::Agent::Database.expects(:close_connections).never
-        @agent.after_fork
-        @agent.instance_eval { transmit_data }
-      end
-
       def test_harvest_transaction_traces
         assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
       end

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -1,9 +1,9 @@
 # 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.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require 'action_controller/test_case'
+
 class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   require 'action_controller/base'
   require 'new_relic/agent/agent_test_controller'
@@ -12,7 +12,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
 
   attr_accessor :agent, :engine
 
-  def test_initialization
+  def suite_initialization
   # Suggested by cee-dub for merb tests.  I'm actually amazed if our tests work with merb.
     if defined?(Merb::Router)
       Merb::Router.prepare do |r|
@@ -25,19 +25,19 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
       end
     else
       Rails.application.routes.draw do
-        match '/:controller/:action.:format'
-        match '/:controller/:action'
+        get '/:controller/:action.:format'
+        get '/:controller/:action'
       end
     end
 
-    if defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:routes)
+    if defined?(Rails) && Rails.respond_to?(:application) &&
+        Rails.application.respond_to?(:routes)
       @routes = Rails.application.routes
     end
 
     Thread.current[:newrelic_ignore_controller] = nil
     NewRelic::Agent.manual_start
     @agent = NewRelic::Agent.instance
-    #    @agent.instrument_app
     agent.transaction_sampler.harvest
     NewRelic::Agent::AgentTestController.class_eval do
       newrelic_ignore :only => [:action_to_ignore, :entry_action, :base_action]
@@ -51,10 +51,10 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   if NewRelic::Control.instance.rails_version <= '2.1.0'
     def initialize name
       super name
-      test_initialization
+      suite_initialization
     end
   else
-    alias_method :setup, :test_initialization
+    alias_method :setup, :suite_initialization
   end
 
   def teardown
@@ -67,8 +67,11 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   def test_mongrel_queue
     NewRelic::Agent::AgentTestController.clear_headers
     engine.clear_stats
-    NewRelic::Control.instance.local_env.stubs(:mongrel).returns( stub('mongrel', :workers => stub('workers', :list => stub('list', :length => '10'))))
-
+    NewRelic::Control.instance.local_env.stubs(:mongrel) \
+      .returns(stub('mongrel',
+                    :workers => stub('workers',
+                                     :list => stub('list',
+                                                   :length => '10'))))
     get :index
     assert_equal 1, stats('HttpDispatcher').call_count
     assert_equal 1, engine.get_stats_no_scope('Mongrel/Queue Length').call_count
@@ -119,6 +122,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_equal 'foofah', @response.body
     compare_metrics %w[Controller/new_relic/agent/agent_test/action_inline], engine.metrics.grep(/^Controller/)
   end
+
   def test_metric__ignore
     engine.clear_stats
     compare_metrics [], engine.metrics
@@ -209,6 +213,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     end
     assert_nil Thread.current[:newrelic_ignore_controller]
   end
+
   def test_metric__ignore_apdex
     engine = @agent.stats_engine
     path = 'new_relic/agent/agent_test/action_to_ignore_apdex'
@@ -221,8 +226,8 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
       end
     end
     assert_nil Thread.current[:newrelic_ignore_controller]
-
   end
+
   def test_metric__dispatched
     engine = @agent.stats_engine
     get :entry_action
@@ -234,6 +239,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController_controller/internal_action')
     assert_not_nil engine.lookup_stats('Controller/NewRelic::Agent::AgentTestController/internal_traced_action')
   end
+
   def test_action_instrumentation
     get :index, :foo => 'bar'
     assert_match /bar/, @response.body
@@ -259,9 +265,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert_equal 5, s.first.params.size
   end
 
-
   def test_busy_calculation_correctly_calculates_based_acccumlator
-
     # woah it's 1970
     now = Time.at 0
 
@@ -332,6 +336,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     assert(queue_time_stat.total_call_time < 10, "Queue time should be under 10 seconds (sanity check)")
 
   end
+
   def test_queue_headers_heroku
     # make this test deterministic
     Time.stubs(:now => Time.at(1360973845))
@@ -382,4 +387,3 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
 end if defined? Rails
-

data/test/new_relic/agent/audit_logger_test.rb

@@ -4,6 +4,7 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require 'new_relic/agent/audit_logger'
+require 'new_relic/agent/null_logger'
 
 class AuditLoggerTest < Test::Unit::TestCase
   def setup
@@ -66,6 +67,17 @@ class AuditLoggerTest < Test::Unit::TestCase
     assert_nil(logger.ensure_log_path)
   end
 
+  def test_setup_logger_creates_null_logger_when_ensure_path_fails
+    null_logger = NewRelic::Agent::NullLogger.new
+    NewRelic::Agent::NullLogger.expects(:new).returns(null_logger)
+    logger = NewRelic::Agent::AuditLogger.new(@config)
+    logger.stubs(:ensure_log_path).returns(nil)
+    assert_nothing_raised do
+      logger.setup_logger
+      logger.log_request(@uri, 'whatever', @marshaller)
+    end
+  end
+
   def test_log_request_captures_system_call_errors
     logger = NewRelic::Agent::AuditLogger.new(@config)
     dummy_sink = StringIO.new

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

@@ -50,5 +50,53 @@ module NewRelic::Agent::Configuration
     def test_should_not_dot_the_web_transactions_apdex_hash
       assert_equal 1.5, @source[:web_transactions_apdex]['Controller/some/txn']
     end
+
+    def test_should_disable_gated_features_when_server_says_to
+      rsp = {
+        'collect_errors' => false,
+        'collect_traces' => false
+      }
+      existing_config = {
+        :'error_collector.enabled'    => true,
+        :'slow_sql.enabled'           => true,
+        :'transaction_tracer.enabled' => true
+      }
+      @source = ServerSource.new(rsp, existing_config)
+      assert !@source[:'error_collector.enabled']
+      assert !@source[:'slow_sql.enabled']
+      assert !@source[:'transaction_tracer.enabled']
+    end
+
+    def test_should_enable_gated_features_when_server_says_to
+      rsp = {
+        'collect_errors' => true,
+        'collect_traces' => true
+      }
+      existing_config = {
+        :'error_collector.enabled'    => true,
+        :'slow_sql.enabled'           => true,
+        :'transaction_tracer.enabled' => true
+      }
+      @source = ServerSource.new(rsp, existing_config)
+      assert @source[:'error_collector.enabled']
+      assert @source[:'slow_sql.enabled']
+      assert @source[:'transaction_tracer.enabled']
+    end
+
+    def test_should_allow_manual_disable_of_gated_features
+      rsp = {
+        'collect_errors' => true,
+        'collect_traces' => true
+      }
+      existing_config = {
+        :'error_collector.enabled'    => false,
+        :'slow_sql.enabled'           => false,
+        :'transaction_tracer.enabled' => false
+      }
+      @source = ServerSource.new(rsp, existing_config)
+      assert !@source[:'error_collector.enabled']
+      assert !@source[:'slow_sql.enabled']
+      assert !@source[:'transaction_tracer.enabled']
+    end
   end
 end

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -190,6 +190,14 @@ module NewRelic::Agent
         NewRelic::Agent::CrossAppMonitor::EncodingFunctions.encode_with_key( nil, 'querty' )
     end
 
+    def test_encoding_functions_can_roundtrip_utf8_text
+      str = 'Анастасі́я Олексі́ївна Каме́нських'
+      encoded = NewRelic::Agent::CrossAppMonitor::EncodingFunctions.obfuscate_with_key( 'potap', str )
+      decoded = NewRelic::Agent::CrossAppMonitor::EncodingFunctions.decode_with_key( 'potap', encoded )
+      decoded.force_encoding( 'utf-8' ) if decoded.respond_to?( :force_encoding )
+      assert_equal str, decoded
+    end
+
     #
     # Helpers
     #

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

@@ -0,0 +1,254 @@
+# 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.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/instrumentation/rails4/action_view'
+
+class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::TestCase
+  def setup
+    @subscriber = NewRelic::Agent::Instrumentation::ActionViewSubscriber.new
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+  end
+
+  def teardown
+    NewRelic::Agent.instance.stats_engine.clear_stats
+  end
+
+  def test_records_metrics_for_simple_template
+    params = { :identifier => '/root/app/views/model/index.html.erb' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'model/index')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'model/index')
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    metric = @stats_engine.lookup_stats('View/model/index.html.erb/Rendering')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_metrics_for_simple_file
+    params = { :identifier => '/root/something.txt' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => nil)
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => nil)
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    metric = @stats_engine.lookup_stats('View/file/Rendering')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_metrics_for_simple_inline
+    params = { :identifier => 'inline template' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => nil)
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => nil)
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    metric = @stats_engine.lookup_stats('View/inline template/Rendering')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_metrics_for_simple_text
+    params = { :identifier => 'text template' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    metric = @stats_engine.lookup_stats('View/text template/Rendering')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_metrics_for_simple_partial
+    params = { :identifier => '/root/app/views/model/_form.html.erb' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_partial.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'model/_form')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'model/_form')
+    @subscriber.finish('render_partial.action_view', :id, params)
+
+    metric = @stats_engine.lookup_stats('View/model/_form.html.erb/Partial')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_metrics_for_simple_collection
+    params = { :identifier => '/root/app/views/model/_user.html.erb' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_collection.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'model/_user')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'model/_user')
+    @subscriber.finish('render_collection.action_view', :id, params)
+
+    metric = @stats_engine.lookup_stats('View/model/_user.html.erb/Partial')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_metrics_for_layout
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0 + 2)
+
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'layouts/application')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'layouts/application')
+
+    metric = @stats_engine.lookup_stats('View/layouts/application/Rendering')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_scoped_metric
+    params = { :identifier => '/root/app/views/model/index.html.erb' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+    @stats_engine.start_transaction('test_txn')
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'model/index')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'model/index')
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    metric = @stats_engine.lookup_stats('View/model/index.html.erb/Rendering',
+                                        'test_txn')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+
+  end
+
+  def test_records_nothing_if_tracing_disabled
+    params = { :identifier => '/root/app/views/model/_user.html.erb' }
+
+    NewRelic::Agent.disable_all_tracing do
+      @subscriber.start('render_collection.action_view', :id, params)
+      @subscriber.finish('render_collection.action_view', :id, params)
+    end
+
+    metric = @stats_engine.lookup_stats('View/model/_user.html.erb/Partial')
+    assert_nil metric
+  end
+
+  def test_creates_txn_segment_for_simple_render
+    params = { :identifier => '/root/app/views/model/index.html.erb' }
+
+    sampler = in_transaction do
+      @subscriber.start('render_template.action_view', :id, params)
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/index')
+      @subscriber.finish('!render_template.action_view', :id,
+                         :virtual_path => 'model/index')
+      @subscriber.finish('render_template.action_view', :id, params)
+    end
+
+    last_segment = nil
+    sampler.last_sample.root_segment.each_segment{|s| last_segment = s }
+    NewRelic::Agent.shutdown
+
+    assert_equal('View/model/index.html.erb/Rendering',
+                 last_segment.metric_name)
+  end
+
+  def test_creates_nested_partial_segment_within_render_segment
+    sampler = in_transaction do
+      @subscriber.start('render_template.action_view', :id,
+                        :identifier => 'model/index.html.erb')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/index')
+      @subscriber.start('render_partial.action_view', :id,
+                        :identifier => '/root/app/views/model/_list.html.erb')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                         :virtual_path => 'model/_list')
+      @subscriber.finish('render_partial.action_view', :id,
+                         :identifier => '/root/app/views/model/_list.html.erb')
+      @subscriber.finish('!render_template.action_view', :id,
+                         :virtual_path => 'model/index')
+      @subscriber.finish('render_template.action_view', :id,
+                         :identifier => 'model/index.html.erb')
+    end
+
+    template_segment = sampler.last_sample.root_segment.called_segments[0].called_segments[0]
+    partial_segment = template_segment.called_segments[0]
+
+    assert_equal('View/model/index.html.erb/Rendering',
+                 template_segment.metric_name)
+    assert_equal('View/model/_list.html.erb/Partial',
+                 partial_segment.metric_name)
+  end
+
+  def test_creates_nodes_for_each_in_a_collection_event
+    sampler = in_transaction do
+      @subscriber.start('render_collection.action_view', :id,
+                        :identifier => '/root/app/views/model/_list.html.erb',
+                        :count => 3)
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('render_collection.action_view', :id,
+                         :identifier => '/root/app/views/model/_list.html.erb',
+                         :count => 3)
+    end
+
+    template_segment = sampler.last_sample.root_segment.called_segments[0]
+    partial_segments = template_segment.called_segments
+
+    assert_equal 3, partial_segments.size
+    assert_equal('View/model/_list.html.erb/Partial',
+                 partial_segments[0].metric_name)
+  end
+
+  def in_transaction
+    NewRelic::Agent.manual_start
+    NewRelic::Agent.instance.stats_engine.start_transaction('test')
+    sampler = NewRelic::Agent.instance.transaction_sampler
+    sampler.notice_first_scope_push(Time.now.to_f)
+    sampler.notice_transaction('/path', '/path', {})
+    sampler.notice_push_scope('Controller/sandwiches/index')
+    yield
+    sampler.notice_pop_scope('Controller/sandwiches/index')
+    sampler.notice_scope_empty
+    sampler
+  ensure
+    NewRelic::Agent.shutdown
+  end
+end if ::Rails::VERSION::MAJOR.to_i >= 4