newrelic_rpm 3.6.8.168 → 3.6.9.171

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

@@ -386,11 +386,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     assert_not_nil sql_segment, sample.to_s
     assert_match /^SELECT /, sql_segment.params[:sql]
     assert sql_segment.duration > 0.0, "Segment duration must be greater than zero."
-    sample = sample.prepare_to_send(:record_sql => :raw, :explain_sql => 0.0)
+    sample = sample.prepare_to_send!(:record_sql => :raw, :explain_sql => 0.0)
     sql_segment = last_segment(sample)
     assert_match /^SELECT /, sql_segment.params[:sql]
     explanations = sql_segment.params[:explain_plan]
-    if isMysql? || isPostgres?
+    if (isMysql? || isPostgres?) && !NewRelic::LanguageSupport.using_engine?('jruby')
       assert_not_nil explanations, "No explains in segment: #{sql_segment}"
       assert_equal(2, explanations.size,
                    "No explains in segment: #{sql_segment}")
@@ -408,7 +408,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
 
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
+    sample = sample.prepare_to_send!(:record_sql => :obfuscated, :explain_sql => 0.0)
     segment = last_segment(sample)
     explanation = segment.params[:explain_plan]
     assert_not_nil explanation, "No explains in segment: #{segment}"
@@ -438,7 +438,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
 
-    sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
+    sample = sample.prepare_to_send!(:record_sql => :obfuscated, :explain_sql => 0.0)
     segment = last_segment(sample)
     explanations = segment.params[:explain_plan]
 
@@ -463,7 +463,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
 
-    sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
+    sample = sample.prepare_to_send!(:record_sql => :obfuscated, :explain_sql => 0.0)
     segment = last_segment(sample)
 
     s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
@@ -517,9 +517,12 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     assert_metrics_recorded(
       'ActiveRecord/all' => { :call_count => 1 },
-      'Database/SQL/select' => { :call_count => 1 },
-      "RemoteService/sql/#{adapter}/localhost" => { :call_count => 1 }
+      'Database/SQL/select' => { :call_count => 1 }
     )
+
+    if !NewRelic::LanguageSupport.using_engine?('jruby')
+      assert_metrics_recorded("RemoteService/sql/#{adapter}/localhost" => { :call_count => 1 })
+    end
   end
 
   def test_rescue_handling
@@ -536,17 +539,17 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   end
 
   def test_remote_service_metric_respects_dynamic_connection_config
-    return unless isMysql?
+    return unless isMysql? && !NewRelic::LanguageSupport.using_engine?('jruby')
 
     ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
-    assert(NewRelic::Agent.get_stats("RemoteService/sql/#{adapter}/localhost").call_count != 0)
+    assert_metrics_recorded(["RemoteService/sql/#{adapter}/localhost"])
 
     config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }
     config[:host] = '127.0.0.1'
     connection = ActiveRecordFixtures::Shipment.establish_connection(config)
 
     ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
-    assert(NewRelic::Agent.get_stats("RemoteService/sql/#{adapter}/127.0.0.1").call_count != 0)
+    assert_metrics_recorded(["RemoteService/sql/#{adapter}/127.0.0.1"])
 
     config[:host] = 'localhost'
     ActiveRecordFixtures::Shipment.establish_connection(config)

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

@@ -16,7 +16,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
     @config = { :adapter => 'mysql', :host => 'server' }
     @connection = Object.new
     @connection.instance_variable_set(:@config, @config)
-    Order.stubs(:connection_pool).returns(stub(:connections => [ @connection ]))
+
 
     @params = {
       :name => 'NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order Load',
@@ -73,6 +73,10 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
   end
 
   def test_records_remote_service_metric
+    connection_pool = stub(:connections => [ @connection ])
+    connection_pool_list = [connection_pool]
+    ::ActiveRecord::Base.connection_handler.stubs(:connection_pool_list).returns(connection_pool_list)
+
     freeze_time
 
     simulate_query(2)
@@ -128,6 +132,17 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit:
     advance_time(duration) if duration
     @subscriber.finish('sql.active_record', :id, @params)
   end
+
+  def test_active_record_config_for_event
+    target_connection = ActiveRecord::Base.connection_handler.connection_pool_list.first.connections.first
+    expected_config = target_connection.instance_variable_get(:@config)
+
+    event = mock('event')
+    event.stubs(:payload).returns({ :connection_id => target_connection.object_id })
+
+    result = @subscriber.active_record_config_for_event(event)
+    assert_equal expected_config, result
+  end
 end
 
 else

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

@@ -147,9 +147,9 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
   end
 
   def test_error_collector_captures_custom_params
-    @agent.error_collector.harvest_errors([])
+    @agent.error_collector.harvest_errors
     run_task_exception rescue nil
-    errors = @agent.error_collector.harvest_errors([])
+    errors = @agent.error_collector.harvest_errors
 
     assert_equal(1, errors.size)
     error = errors.first

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

@@ -5,7 +5,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
 class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Test::Unit::TestCase
   require 'new_relic/agent/method_tracer'
-  include NewRelic::Agent::MethodTracer::TraceExecutionScoped
+  include NewRelic::Agent::MethodTracer
 
   def setup
     NewRelic::Agent.agent.stats_engine.clear_stats

data/test/new_relic/agent/new_relic_service_test.rb

@@ -2,6 +2,7 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
+require 'cgi'
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
 require 'new_relic/agent/commands/thread_profiler_session'
 
@@ -190,11 +191,37 @@ class NewRelicServiceTest < Test::Unit::TestCase
     dummy_rsp = 'met rick date uhh'
     @http_handle.respond_to(:metric_data, dummy_rsp)
     stats_hash = NewRelic::Agent::StatsHash.new
+    stats_hash.harvested_at = Time.now
     @service.expects(:fill_metric_id_cache).with(dummy_rsp)
-    response = @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
+    response = @service.metric_data(stats_hash)
+
+    assert_equal 4, @http_handle.last_request_payload.size
     assert_equal dummy_rsp, response
   end
 
+  def test_metric_data_sends_harvest_timestamps
+    @http_handle.respond_to(:metric_data, 'foo')
+    @service.stubs(:fill_metric_id_cache)
+
+    t0 = freeze_time
+    stats_hash = NewRelic::Agent::StatsHash.new
+    stats_hash.harvested_at = Time.now
+
+    @service.metric_data(stats_hash)
+    payload = @http_handle.last_request_payload
+    _, last_harvest_timestamp, harvest_timestamp, _ = payload
+    assert_equal(t0.to_f, harvest_timestamp)
+
+    t1 = advance_time(10)
+    stats_hash.harvested_at = t1
+
+    @service.metric_data(stats_hash)
+    payload = @http_handle.last_request_payload
+    _, last_harvest_timestamp, harvest_timestamp, _ = payload
+    assert_equal(t1.to_f, harvest_timestamp)
+    assert_equal(t0.to_f, last_harvest_timestamp)
+  end
+
   def test_fill_metric_id_cache_from_collect_response
     response = [[{"scope"=>"Controller/blogs/index", "name"=>"Database/SQL/other"}, 1328],
                 [{"scope"=>"", "name"=>"WebFrontend/QueueTime"}, 10],
@@ -212,13 +239,11 @@ class NewRelicServiceTest < Test::Unit::TestCase
     dummy_rsp = [[{ 'name' => 'a', 'scope' => '' }, 42]]
     @http_handle.respond_to(:metric_data, dummy_rsp)
 
-    hash = NewRelic::Agent::StatsHash.new
-    hash.record(NewRelic::MetricSpec.new('a'), 1)
+    hash = build_stats_hash('a' => 1)
 
-    @service.metric_data((Time.now - 60).to_f, Time.now.to_f, hash)
+    @service.metric_data(hash)
 
-    hash = NewRelic::Agent::StatsHash.new
-    hash.record(NewRelic::MetricSpec.new('a'), 1)
+    hash = build_stats_hash('a' => 1)
     stats = hash[NewRelic::MetricSpec.new('a')]
 
     results = @service.build_metric_data_array(hash)
@@ -227,6 +252,22 @@ class NewRelicServiceTest < Test::Unit::TestCase
     assert_equal(42, results.first.metric_id)
   end
 
+  def test_metric_data_tracks_last_harvest_time
+    t0 = freeze_time
+
+    @http_handle.respond_to(:metric_data, [])
+
+    hash = build_stats_hash('a' => 1)
+    advance_time(1)
+    @service.metric_data(hash)
+    assert_equal(t0, @service.last_metric_harvest_time)
+
+    t1 = advance_time(60)
+    hash = build_stats_hash('a' => 1)
+    @service.metric_data(hash)
+    assert_equal(t1, @service.last_metric_harvest_time)
+  end
+
   def test_error_data
     @http_handle.respond_to(:error_data, 'too human')
     response = @service.error_data([])
@@ -301,7 +342,8 @@ class NewRelicServiceTest < Test::Unit::TestCase
     @http_handle.respond_to(:metric_data, 0)
     @service.stubs(:fill_metric_id_cache)
     stats_hash = NewRelic::Agent::StatsHash.new
-    @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
+    stats_hash.harvested_at = Time.now
+    @service.metric_data(stats_hash)
 
     @http_handle.respond_to(:transaction_sample_data, 1)
     @service.transaction_sample_data([])
@@ -324,7 +366,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
     @http_handle.respond_to(:metric_data, 'too big', :code => 413)
     assert_raise NewRelic::Agent::UnrecoverableServerException do
       stats_hash = NewRelic::Agent::StatsHash.new
-      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
+      @service.metric_data(stats_hash)
     end
   end
 
@@ -333,7 +375,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
     @http_handle.respond_to(:metric_data, 'too big', :code => 415)
     assert_raise NewRelic::Agent::UnrecoverableServerException do
       stats_hash = NewRelic::Agent::StatsHash.new
-      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
+      @service.metric_data(stats_hash)
     end
   end
 
@@ -482,6 +524,15 @@ class NewRelicServiceTest < Test::Unit::TestCase
     assert_equal(spec1, metric_data.metric_spec)
   end
 
+  def build_stats_hash(items={})
+    hash = NewRelic::Agent::StatsHash.new
+    items.each do |key, value|
+      hash.record(NewRelic::MetricSpec.new(key), value)
+    end
+    hash.harvested_at = Time.now
+    hash
+  end
+
   class HTTPHandle
     attr_accessor :read_timeout, :route_table
 
@@ -529,6 +580,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
     end
 
     def request(*args)
+      @last_request = args.first
       @route_table.each_pair do |condition, response|
         if condition.call(args[0])
           return response
@@ -539,6 +591,23 @@ class NewRelicServiceTest < Test::Unit::TestCase
 
     def reset
       @route_table = {}
+      @last_request = nil
+    end
+
+    def last_request
+      @last_request
+    end
+
+    def last_request_payload
+      return nil unless @last_request && @last_request.body
+      uri = URI.parse(@last_request.path)
+      params = CGI.parse(uri.query)
+      format = params['marshal_format'].first
+      if format == 'json'
+        JSON.load(@last_request.body)
+      else
+        Marshal.load(@last_request.body)
+      end
     end
   end
 

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -11,6 +11,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
 
   def setup
     @test_config = { :developer_mode => true }
+    NewRelic::Agent.agent.reset_stats
     NewRelic::Agent.config.apply_config(@test_config)
     NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
     NewRelic::Agent.manual_start
@@ -46,7 +47,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
         NewRelic::Agent.after_fork
         new_engine = NewRelic::Agent::StatsEngine.new
         new_engine.get_stats_no_scope(metric).record_data_point(2.0)
-        listener.pipes[666].write(:stats => new_engine.harvest_timeslice_data({}))
+        listener.pipes[666].write(:stats => new_engine.harvest)
       end
       Process.wait(pid)
       listener.stop
@@ -57,24 +58,21 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
 
     def test_listener_merges_transaction_traces
       sampler = NewRelic::Agent.agent.transaction_sampler
-      run_sample_trace_on(sampler)
-      NewRelic::Agent.agent.merge_data_from([nil, [[sampler.last_sample]], nil])
-
-      assert_equal(1, NewRelic::Agent.agent.unsent_traces_size)
+      sample = run_sample_trace_on(sampler)
+      assert_equal(1, sampler.count)
 
       listener = start_listener_with_pipe(667)
-
       pid = Process.fork do
         NewRelic::Agent.after_fork
         with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
           sample = run_sample_trace_on(sampler)
-          listener.pipes[667].write(:transaction_traces => sampler.harvest([]))
+          listener.pipes[667].write(:transaction_traces => sampler.harvest)
         end
       end
       Process.wait(pid)
       listener.stop
 
-      assert_equal(2, NewRelic::Agent.agent.unsent_traces_size)
+      assert_equal(2, sampler.count)
     end
 
     def test_listener_merges_error_traces
@@ -95,7 +93,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
         new_sampler.notice_error(Exception.new("new message"), :uri => '/myurl/',
                                  :metric => 'path', :referer => 'test_referer',
                                  :request_params => {:x => 'y'})
-        listener.pipes[668].write(:error_traces => new_sampler.harvest_errors([]))
+        listener.pipes[668].write(:error_traces => new_sampler.harvest_errors)
       end
       Process.wait(pid)
       listener.stop

data/test/new_relic/agent/pipe_service_test.rb

@@ -34,7 +34,7 @@ class PipeServiceTest < Test::Unit::TestCase
       .with(regexp_matches(/No communication channel to parent process/)).once
     service = NewRelic::Agent::PipeService.new(:non_existant)
     assert_nothing_raised do
-      service.metric_data(Time.now, Time.now, {})
+      service.metric_data({})
     end
   end
 
@@ -44,7 +44,7 @@ class PipeServiceTest < Test::Unit::TestCase
     def test_metric_data
       received_data = data_from_forked_process do
         metric_data0 = generate_metric_data('Custom/something')
-        @service.metric_data(0.0, 0.1, metric_data0)
+        @service.metric_data(metric_data0)
       end
 
       assert_equal 'Custom/something', received_data[:stats].keys.sort[0].name
@@ -75,7 +75,7 @@ class PipeServiceTest < Test::Unit::TestCase
     def test_multiple_writes_to_pipe
       pid = Process.fork do
         metric_data0 = generate_metric_data('Custom/something')
-        @service.metric_data(0.0, 0.1, metric_data0)
+        @service.metric_data(metric_data0)
         @service.transaction_sample_data(['txn0'])
         @service.error_data(['err0'])
         @service.sql_trace_data(['sql0'])
@@ -102,7 +102,7 @@ class PipeServiceTest < Test::Unit::TestCase
   def generate_metric_data(metric_name, data=1.0)
     engine = NewRelic::Agent::StatsEngine.new
     engine.get_stats_no_scope(metric_name).record_data_point(data)
-    engine.harvest_timeslice_data({})
+    engine.harvest
   end
 
   def read_from_pipe

data/test/new_relic/agent/request_sampler_test.rb

@@ -59,7 +59,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
       old_samples = @sampler.harvest
       5.times { generate_request }
 
-      @sampler.merge(old_samples)
+      @sampler.merge!(old_samples)
       assert_equal(10, @sampler.samples.size)
     end
   end
@@ -70,7 +70,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
       old_samples = @sampler.harvest
       4.times { generate_request }
 
-      @sampler.merge(old_samples)
+      @sampler.merge!(old_samples)
       assert_equal(5, @sampler.samples.size)
     end
   end

data/test/new_relic/agent/stats_engine/gc_profiler_test.rb

@@ -6,57 +6,39 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_h
 
 class NewRelic::Agent::StatsEngine::GCProfilerTest < Test::Unit::TestCase
   def test_init_profiler_for_rails_bench
+    return unless defined?(::GC) && ::GC.respond_to?(:collections)
+
     ::GC.stubs(:time)
     ::GC.stubs(:collections)
 
-    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::RailsBench,
+    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::RailsBenchProfiler,
                  NewRelic::Agent::StatsEngine::GCProfiler.init.class)
   end
 
-  def test_init_profiler_for_ruby_19
-    defined = defined?(::GC::Profiler)
-    if !defined
-      ::GC.const_set(:Profiler, Module.new)
-    end
+  def test_init_profiler_for_ruby_19_and_greater
+    return unless defined?(::GC::Profiler)
+    return if NewRelic::LanguageSupport.using_engine?('jruby')
+
     ::GC::Profiler.stubs(:enabled?).returns(true)
     ::GC::Profiler.stubs(:total_time).returns(0)
     ::GC.stubs(:count).returns(0)
 
-    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::Ruby19,
+    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::CoreGCProfiler,
                  NewRelic::Agent::StatsEngine::GCProfiler.init.class)
-  ensure
-    ::GC.send(:remove_const, :Profiler) unless defined
   end
 
-  def test_init_profiler_for_rbx
-    defined = defined?(::Rubinius::GC)
-    if !defined
-      Object.const_set(:Rubinius, Module.new)
-      ::Rubinius.const_set(:GC, Module.new)
-    end
-    ::Rubinius::GC.stubs(:count).returns(0)
-    ::Rubinius::GC.stubs(:time).returns(0)
+  def test_init_profiler_for_rbx_uses_stdlib
+    return unless defined?(::Rubinius::GC)
 
-    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::Rubinius,
+    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::CoreGCProfiler,
                  NewRelic::Agent::StatsEngine::GCProfiler.init.class)
-  ensure
-    Object.send(:remove_const, :Rubinius) unless defined
   end
 
   def test_collect_gc_data
-    GC.disable unless NewRelic::LanguageSupport.using_engine?('jruby')
-    if NewRelic::LanguageSupport.using_engine?('rbx')
-      agent = ::Rubinius::Agent.loopback
-      agent.stubs(:get).with('system.gc.young.total_wallclock') \
-        .returns([:value, 1000], [:value, 2500])
-      agent.stubs(:get).with('system.gc.full.total_wallclock') \
-        .returns([:value, 2000], [:value, 3500])
-      agent.stubs(:get).with('system.gc.young.count') \
-        .returns([:value, 1], [:value, 2])
-      agent.stubs(:get).with('system.gc.full.count') \
-        .returns([:value, 1], [:value, 2])
-      ::Rubinius::Agent.stubs(:loopback).returns(agent)
-    elsif NewRelic::LanguageSupport.using_version?('1.9')
+    return if NewRelic::LanguageSupport.using_engine?('jruby')
+
+    GC.disable
+    if NewRelic::LanguageSupport.using_version?('1.9')
       ::GC::Profiler.stubs(:enabled?).returns(true)
       ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0)
       ::GC.stubs(:count).returns(1, 3)
@@ -80,7 +62,5 @@ class NewRelic::Agent::StatsEngine::GCProfilerTest < Test::Unit::TestCase
     assert_equal 2, gc_stats.call_count
     assert_equal 3.0, gc_stats.total_call_time
     assert_equal(3.0, tracer.last_sample.params[:custom_params][:gc_time])
-  ensure
-    GC.enable unless NewRelic::LanguageSupport.using_engine?('jruby')
   end
 end