newrelic_rpm 3.13.2.302 → 3.14.0.305

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -82,9 +82,10 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
       sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
                            :metric => 'path', :referer => 'test_referer',
                            :request_params => {:x => 'y'})
-      NewRelic::Agent.agent.merge_data_for_endpoint(:error_data, sampler.errors)
+      NewRelic::Agent.agent.merge_data_for_endpoint(:error_data, sampler.error_trace_aggregator.harvest!)
 
-      assert_equal(1, NewRelic::Agent.agent.error_collector.errors.size)
+      errors = NewRelic::Agent.agent.error_collector.error_trace_aggregator.instance_variable_get :@errors
+      assert_equal(1, errors.size)
 
       start_listener_with_pipe(668)
 
@@ -95,10 +96,10 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
                                  :metric => 'path', :referer => 'test_referer',
                                  :request_params => {:x => 'y'})
         service = NewRelic::Agent::PipeService.new(668)
-        service.error_data(new_sampler.harvest!)
+        service.error_data(new_sampler.error_trace_aggregator.harvest!)
       end
-
-      assert_equal(2, NewRelic::Agent.agent.error_collector.errors.size)
+      errors = NewRelic::Agent.agent.error_collector.error_trace_aggregator.instance_variable_get :@errors
+      assert_equal(2, errors.size)
     end
 
     def test_listener_merges_analytics_events

data/test/new_relic/agent/sampled_buffer_test.rb

@@ -102,5 +102,41 @@ module NewRelic::Agent
       buffer.reset!
       assert_equal(0.5, buffer.sample_rate_lifetime)
     end
+
+    def test_append_with_block
+      buffer = buffer_class.new(5)
+      5.times do |i|
+        buffer.append { i }
+      end
+
+      assert_equal [0, 1, 2, 3, 4], buffer.to_a
+    end
+
+    def test_append_with_block_while_sampling
+      buffer = buffer_class.new(5)
+      buffer.stubs(:rand).returns(0)
+
+      10.times do |i|
+        buffer.append { i }
+      end
+
+      assert_equal [9, 1, 2, 3, 4], buffer.to_a
+    end
+
+    def test_append_with_block_increments_seen
+      buffer = buffer_class.new(5)
+      10.times do |i|
+        buffer.append { i }
+      end
+
+      assert_equal 10, buffer.num_seen
+    end
+
+    def test_append_does_not_allow_an_argument_and_block
+      assert_raises ArgumentError do
+        buffer = buffer_class.new 5
+        buffer.append(4) { 5 }
+      end
+    end
   end
 end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -328,13 +328,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!
 
-      if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-        marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-        params = "eJyrrgUAAXUA+Q==\n"
-      else
-        marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
-        params = {}
-      end
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      params = "eJyrrgUAAXUA+Q==\n"
 
       expected = [ 'WebTransaction/Controller/c/a', '/c/a', 526336943,
                    'select * from test', 'Database/test/select',
@@ -351,13 +346,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     trace.call_count = Rational(10, 1)
     trace.instance_variable_set(:@sql_id, "1234")
 
-    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      params = "eJyrrgUAAXUA+Q==\n"
-    else
-      marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
-      params = {}
-    end
+    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    params = "eJyrrgUAAXUA+Q==\n"
 
     expected = [ "path", "uri", 1234, "query", "transaction",
                  10, 12000, 12000, 12000, params]

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

@@ -7,7 +7,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..','tes
 class NewRelic::Agent::StatsHashTest < Minitest::Test
   def setup
     @hash = NewRelic::Agent::StatsHash.new
-    NewRelic::Agent.instance.error_collector.errors.clear
+    reset_error_traces!
   end
 
   def test_creates_default_entries
@@ -170,17 +170,18 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
 
       @hash.record(DEFAULT_SPEC, 1)
 
-      assert_has_error NewRelic::Agent::StatsHash::StatsHashLookupError
+      assert_has_traced_error NewRelic::Agent::StatsHash::StatsHashLookupError
     end
 
     def test_borked_default_proc_heals_thyself
       fake_borked_default_proc(@hash)
 
       @hash.record(DEFAULT_SPEC, 1)
-      NewRelic::Agent.instance.error_collector.errors.clear
+      reset_error_traces!
 
       @hash.record(NewRelic::MetricSpec.new('something/else/entirely'), 1)
-      assert_equal 0, NewRelic::Agent.instance.error_collector.errors.size
+      errors = harvest_error_traces!
+      assert_equal 0, errors.size
     end
   end
 

data/test/new_relic/agent/threading/thread_profile_test.rb

@@ -123,8 +123,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
           0
         ]
 
-        identity_encoder = NewRelic::Agent::NewRelicService::PrubyMarshaller.new.default_encoder
-        assert_equal expected, @profile.to_collector_array(identity_encoder)
+        assert_equal expected, @profile.to_collector_array(NewRelic::Agent::NewRelicService::Encoders::Identity)
       end
 
       def test_to_collector_array_with_xray_session_id

data/test/new_relic/agent/transaction/request_attributes_test.rb

@@ -0,0 +1,76 @@
+# 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/transaction/request_attributes'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class RequestAttributesTest < Minitest::Test
+
+        def test_tolerates_request_without_desired_methods
+          request = stub 'request'
+          attrs = RequestAttributes.new request
+
+          assert_equal "/", attrs.request_path
+          assert_nil attrs.referer
+          assert_nil attrs.content_length
+          assert_nil attrs.host
+          assert_nil attrs.user_agent
+          assert_nil attrs.request_method
+        end
+
+        def test_sets_referer_from_request
+          request = stub 'request', :referer => "http://site.com/page"
+          attrs = RequestAttributes.new request
+
+          assert_equal "http://site.com/page", attrs.referer
+        end
+
+        def test_sets_accept_from_request_headers
+          request = stub 'request', :env => {"HTTP_ACCEPT" => "application/json"}
+          attrs = RequestAttributes.new request
+
+          assert_equal "application/json", attrs.accept
+        end
+
+        def test_sets_content_length_from_request
+          request = stub 'request', :content_length => "111"
+          attrs = RequestAttributes.new request
+
+          assert_equal 111, attrs.content_length
+        end
+
+        def test_sets_host_from_request
+          request = stub 'request', :host => "localhost"
+          attrs = RequestAttributes.new request
+
+          assert_equal "localhost", attrs.host
+        end
+
+        def test_sets_port_from_request
+          request = stub 'request', :port => "3000"
+          attrs = RequestAttributes.new request
+
+          assert_equal 3000, attrs.port
+        end
+
+        def test_sets_user_agent_from_request
+          request = stub 'request', :user_agent => "use this!"
+          attrs = RequestAttributes.new request
+
+          assert_equal "use this!", attrs.user_agent
+        end
+
+        def test_sets_method_from_request
+          request = stub 'request', :request_method => "POST"
+          attrs = RequestAttributes.new request
+
+          assert_equal "POST", attrs.request_method
+        end
+      end
+    end
+  end
+end

data/test/new_relic/agent/transaction_event_aggregator_test.rb

@@ -68,6 +68,16 @@ class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
     end
   end
 
+  def test_error_is_included_in_event_data
+    with_sampler_config do
+      generate_request('whatever', :error => true)
+
+      event_data, *_ = captured_transaction_event
+
+      assert event_data['error']
+    end
+  end
+
   def test_includes_custom_attributes_in_event
     with_sampler_config do
       attributes.merge_custom_attributes('bing' => 2)
@@ -396,7 +406,8 @@ class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
       :type => :controller,
       :start_timestamp => options[:timestamp] || Time.now.to_f,
       :duration => 0.1,
-      :attributes => attributes
+      :attributes => attributes,
+      :error => false
     }.merge(options)
     @event_listener.notify(:transaction_finished, payload)
   end

data/test/new_relic/agent/transaction_test.rb

@@ -9,7 +9,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
   def setup
     @stats_engine = NewRelic::Agent.instance.stats_engine
     @stats_engine.reset!
-    NewRelic::Agent.instance.error_collector.reset!
+    NewRelic::Agent.instance.error_collector.drop_buffered_data
   end
 
   def teardown
@@ -698,8 +698,8 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     txn = in_transaction('oops') do
       NewRelic::Agent::Transaction.notice_error("wat?")
     end
-
-    error = NewRelic::Agent.instance.error_collector.errors.first
+    errors = harvest_error_traces!
+    error = errors.first
     assert_equal txn.attributes, error.attributes
   end
 
@@ -708,13 +708,15 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
       # no-op
     end
     NewRelic::Agent::Transaction.notice_error("")
-    assert_equal 1, NewRelic::Agent.instance.error_collector.errors.count
+    errors = harvest_error_traces!
+    assert_equal 1, errors.count
   end
 
   def test_notice_error_without_transaction_notifies_error_collector
     cleanup_transaction
     NewRelic::Agent::Transaction.notice_error("")
-    assert_equal 1, NewRelic::Agent.instance.error_collector.errors.count
+    errors = harvest_error_traces!
+    assert_equal 1, errors.count
   end
 
   def test_notice_error_sends_uri_and_referer_from_request
@@ -723,8 +725,10 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
       NewRelic::Agent::Transaction.notice_error("wat")
     end
 
-    assert_equal 1, NewRelic::Agent.instance.error_collector.errors.count
-    error = NewRelic::Agent.instance.error_collector.errors.first
+    errors = harvest_error_traces!
+    assert_equal 1, errors.count
+
+    error = errors.first
     assert_equal "/here",  error.request_uri
   end
 
@@ -1407,8 +1411,8 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
   end
 
   def test_http_response_code_included_in_agent_attributes
-    txn = in_transaction do |txn|
-      txn.http_response_code = 418
+    txn = in_transaction do |t|
+      t.http_response_code = 418
     end
 
     actual = txn.attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER)
@@ -1417,7 +1421,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
 
   def test_referer_in_agent_attributes
     request = stub('request', :referer => "/referered", :path => "/")
-    txn = in_transaction(:request => request) do |txn|
+    txn = in_transaction(:request => request) do
     end
 
     actual = txn.attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
@@ -1426,10 +1430,55 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
 
   def test_referer_omitted_if_not_on_request
     request = stub('request', :path => "/")
-    txn = in_transaction(:request => request) do |txn|
+    txn = in_transaction(:request => request) do
     end
 
     actual = txn.attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER)
     refute_includes actual, :'request.headers.referer'
   end
+
+  def test_error_recorded_predicate_false_by_default
+    txn = in_transaction do
+    end
+
+    refute txn.error_recorded?, "Did not expected error to be recorded"
+  end
+
+  def test_error_recorded_predicate_true_when_error_recorded
+    txn = in_transaction do |t|
+      t.notice_error StandardError.new "Sorry!"
+    end
+
+    assert txn.error_recorded?, "Expected error to be recorded"
+  end
+
+  def test_error_recorded_predicate_abides_by_ignore_filter
+    filter = Proc.new do |error|
+      error.message == "Sorry!" ? nil : error
+    end
+
+    with_ignore_error_filter filter do
+      txn = in_transaction do |t|
+        t.notice_error StandardError.new "Sorry!"
+      end
+
+      refute txn.error_recorded?, "Expected error to be apologetic"
+    end
+  end
+
+  def test_error_recorded_with_ignore_filter_and_multiple_errors
+    filter = Proc.new do |error|
+      error.message == "Sorry!" ? nil : error
+    end
+
+    with_ignore_error_filter filter do
+      txn = in_transaction do |t|
+        t.notice_error StandardError.new "Sorry!"
+        t.notice_error StandardError.new "Not Sorry!"
+        t.notice_error StandardError.new "Sorry!"
+      end
+
+      assert txn.error_recorded?, "Expected error to be recorded"
+    end
+  end
 end

data/test/new_relic/data_container_tests.rb

@@ -29,11 +29,19 @@ module NewRelic
       self.respond_to?(:max_data_items) ? max_data_items : 5
     end
 
+    def harvest_size container, items
+      if container.respond_to?(:has_metadata?) && container.has_metadata? && !items.empty?
+        items.last.size
+      else
+        items.size
+      end
+    end
+
     def test_harvest_should_return_all_data_items
       c = create_container
       populate_container(c, num_data_items)
       results = c.harvest!
-      assert_equal(num_data_items, results.size)
+      assert_equal(num_data_items, harvest_size(c, results))
     end
 
     def test_calling_harvest_again_should_not_return_items_again
@@ -42,16 +50,18 @@ module NewRelic
 
       c.harvest! # clears container
       results = c.harvest!
-      assert_equal(0, results.size)
+      assert_equal(0, harvest_size(c, results))
     end
 
     def test_calling_harvest_after_re_populating_works
       container = create_container
       populate_container(container, num_data_items)
-      assert_equal(num_data_items, container.harvest!.size)
+      results = container.harvest!
+      assert_equal(num_data_items, harvest_size(container, results))
 
       populate_container(container, num_data_items)
-      assert_equal(num_data_items, container.harvest!.size)
+      results = container.harvest!
+      assert_equal(num_data_items, harvest_size(container, results))
     end
   end
 
@@ -62,7 +72,8 @@ module NewRelic
       c = create_container
       populate_container(c, 5)
       c.reset!
-      assert_equal(0, c.harvest!.size)
+      results = c.harvest!
+      assert_equal(0, harvest_size(c, results))
     end
 
     def test_merge_should_re_integrate_items
@@ -70,7 +81,7 @@ module NewRelic
       populate_container(c, 5)
       c.merge!(c.harvest!)
       results = c.harvest!
-      assert_equal(5, results.size)
+      assert_equal(5, harvest_size(c, results))
     end
   end
 end

data/test/new_relic/fake_collector.rb

@@ -71,6 +71,7 @@ module NewRelic
         'shutdown'                => Response.new(200, {'return_value' => nil}),
         'analytic_event_data'     => Response.new(200, {'return_value' => nil}),
         'custom_event_data'       => Response.new(200, {'return_value' => nil}),
+        'error_event_data'        => Response.new(200, {'return_value' => nil})
       }
       reset
     end
@@ -113,15 +114,10 @@ module NewRelic
 
       if uri.path =~ /agent_listener\/\d+\/.+\/(\w+)/
         method = $1
-        format = json_format?(uri) ? :json : :pruby
         if @mock.keys.include? method
           status, body = @mock[method].evaluate
           res.status = status
-          if format == :json
-            res.write ::NewRelic::JSONWrapper.dump(body)
-          else
-            res.write Marshal.dump(body)
-          end
+          res.write ::NewRelic::JSONWrapper.dump(body)
         else
           res.status = 500
           res.write "Method not found"
@@ -133,15 +129,7 @@ module NewRelic
           raw_body = req.body.read
           raw_body = Zlib::Inflate.inflate(raw_body) if req.env["HTTP_CONTENT_ENCODING"] == "deflate"
 
-          body = if format == :json
-            body = ::NewRelic::JSONWrapper.load(raw_body)
-          else
-            body = Marshal.load(raw_body)
-
-            # Symbols remain in Ruby-marshalled data, so tidy up so tests can
-            # rely on strings to compare against in fake collector results.
-            body = NewRelic::Agent::EncodingNormalizer.normalize_object(body)
-          end
+          body = ::NewRelic::JSONWrapper.load(raw_body)
         rescue
           body = "UNABLE TO DECODE BODY: #{raw_body}"
 
@@ -156,16 +144,12 @@ module NewRelic
         @agent_data << AgentPost.create(:action       => method,
                                         :body         => body,
                                         :run_id       => run_id,
-                                        :format       => format,
+                                        :format       => :json,
                                         :query_params => query_params)
       end
       res.finish
     end
 
-    def json_format?(uri)
-      uri.query && uri.query.include?('marshal_format=json')
-    end
-
     def app
       self
     end
@@ -211,6 +195,8 @@ module NewRelic
           AnalyticEventDataPost.new(opts)
         when 'error_data'
           ErrorDataPost.new(opts)
+        when 'error_event_data'
+          ErrorEventDataPost.new(opts)
         else
           new(opts)
         end
@@ -397,6 +383,15 @@ module NewRelic
         @params["intrinsics"]
       end
     end
-  end
 
+    class ErrorEventDataPost < AgentPost
+      attr_reader :reservoir_metadata, :error_events
+
+      def initialize opts={}
+        super
+        @reservoir_metadata = body[1]
+        @error_events = body[2]
+      end
+    end
+  end
 end