RubyGems - newrelic_rpm - Versions diffs - 4.1.0.333 → 4.2.0.334 - Mend

newrelic_rpm 4.1.0.333 → 4.2.0.334

Files changed (788) hide show

data/test/new_relic/agent/transaction/tracing_test.rb DELETED Viewed

@@ -1,176 +0,0 @@
-# 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'
-module NewRelic
-  module Agent
-    class Transaction
-      class TracingTest < Minitest::Test
-        def setup
-          freeze_time
-        end
-        def teardown
-          NewRelic::Agent.drop_buffered_data
-        end
-        def test_segment_bound_to_transaction_records_metrics
-          in_transaction "test_txn" do
-            segment = Transaction.start_segment  "Custom/simple/segment", "Segment/all"
-            segment.start
-            advance_time 1.0
-            segment.finish
-            refute_metrics_recorded ["Custom/simple/segment", "Segment/all"]
-          end
-          assert_metrics_recorded ["Custom/simple/segment", "Segment/all"]
-        end
-        def test_segment_bound_to_transaction_invokes_complete_callback_when_finished
-          in_transaction "test_txn" do |txn|
-            segment = Transaction.start_segment  "Custom/simple/segment", "Segment/all"
-            txn.expects(:segment_complete).with(segment)
-            segment.start
-            advance_time 1.0
-            segment.finish
-            #clean up traced method stack
-            txn.unstub(:segment_complete)
-            txn.segment_complete(segment)
-          end
-        end
-        def test_segment_data_is_copied_to_trace
-          segment = nil
-          segment_name = "Custom/simple/segment"
-          in_transaction "test_txn" do
-            segment = Transaction.start_segment  segment_name, "Segment/all"
-            segment.start
-            advance_time 1.0
-            segment.finish
-          end
-          trace = last_transaction_trace
-          node = find_node_with_name(trace, segment_name)
-          refute_nil node, "Expected trace to have node with name: #{segment_name}"
-          assert_equal segment.duration, node.duration
-        end
-        def test_start_segment
-          in_transaction "test_txn" do |txn|
-            segment = Transaction.start_segment "Custom/segment/method"
-            assert_equal Time.now, segment.start_time
-            assert_equal txn, segment.transaction
-            advance_time 1
-            segment.finish
-            assert_equal Time.now, segment.end_time
-          end
-        end
-        def test_start_datastore_segment
-          in_transaction "test_txn" do |txn|
-            segment = Transaction.start_datastore_segment "SQLite", "insert", "Blog"
-            assert_equal Time.now, segment.start_time
-            assert_equal txn, segment.transaction
-            advance_time 1
-            segment.finish
-            assert_equal Time.now, segment.end_time
-          end
-        end
-        def test_start_datastore_segment_provides_defaults_without_params
-          segment = Transaction.start_datastore_segment
-          segment.finish
-          assert_equal "Datastore/operation/Unknown/other", segment.name
-          assert_equal "Unknown", segment.product
-          assert_equal "other", segment.operation
-        end
-        def test_start_datastore_segment_does_not_record_metrics_outside_of_txn
-          segment = Transaction.start_datastore_segment "SQLite", "insert", "Blog"
-          segment.start
-          advance_time 1
-          segment.finish
-          refute_metrics_recorded [
-            "Datastore/statement/SQLite/Blog/insert",
-            "Datastore/operation/SQLite/insert",
-            "Datastore/SQLite/allWeb",
-            "Datastore/SQLite/all",
-            "Datastore/allWeb",
-            "Datastore/all"
-          ]
-        end
-        def test_start_segment_with_tracing_disabled_in_transaction
-          segment = nil
-          in_transaction "test_txn" do |txn|
-            NewRelic::Agent.disable_all_tracing do
-              segment = Transaction.start_segment "Custom/segment/method", "Custom/all"
-              advance_time 1
-              segment.finish
-            end
-          end
-          assert_nil segment.transaction, "Did not expect segment to associated with a transaction"
-          refute_metrics_recorded ["Custom/segment/method", "Custom/all"]
-        end
-        def test_current_segment_in_transaction
-          in_transaction "test_txn" do |txn|
-            segment = Transaction.start_datastore_segment "SQLite", "insert", "Blog"
-            assert_equal segment, txn.current_segment
-            segment.finish
-          end
-        end
-        def test_segment_started_oustide_txn_does_not_record_metrics
-          segment = Transaction.start_segment "Custom/segment/method", "Custom/all"
-          advance_time 1
-          segment.finish
-          assert_nil segment.transaction, "Did not expect segment to associated with a transaction"
-          refute_metrics_recorded ["Custom/segment/method", "Custom/all"]
-        end
-        def test_start_external_request_segment
-          in_transaction "test_txn" do |txn|
-            segment = Transaction.start_external_request_segment "Net::HTTP", "http://site.com/endpoint", "GET"
-            assert_equal Time.now, segment.start_time
-            assert_equal txn, segment.transaction
-            assert_equal "Net::HTTP", segment.library
-            assert_equal "http://site.com/endpoint", segment.uri.to_s
-            assert_equal "GET", segment.procedure
-            advance_time 1
-            segment.finish
-            assert_equal Time.now, segment.end_time
-          end
-        end
-        def test_segment_does_not_record_metrics_outside_of_txn
-          segment = Transaction.start_external_request_segment "Net::HTTP", "http://remotehost.com/blogs/index", "GET"
-          segment.finish
-          refute_metrics_recorded [
-            "External/remotehost.com/Net::HTTP/GET",
-            "External/all",
-            "External/remotehost.com/all",
-            "External/allWeb",
-            ["External/remotehost.com/Net::HTTP/GET", "test"]
-          ]
-        end
-      end
-    end
-  end
-end

data/test/new_relic/agent/transaction/xray_sample_buffer_test.rb DELETED Viewed

@@ -1,71 +0,0 @@
-# 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'))
-class NewRelic::Agent::Transaction
-  class XraySampleBufferTest < Minitest::Test
-    XRAY_SESSION_ID = 123
-    MATCHING_TRANSACTION = "Matching/transaction/name"
-    def setup
-      @xray_session_collection = stub
-      @xray_session_collection.stubs(:session_id_for_transaction_name).with(any_parameters).returns(nil)
-      @xray_session_collection.stubs(:session_id_for_transaction_name).with(MATCHING_TRANSACTION).returns(XRAY_SESSION_ID)
-      @buffer = XraySampleBuffer.new
-      @buffer.xray_session_collection = @xray_session_collection
-    end
-    def test_doesnt_store_if_not_matching_transaction
-      sample = sample_with(:transaction_name => "Meaningless/transaction/name")
-      @buffer.store(sample)
-      assert @buffer.samples.empty?
-    end
-    def test_stores_if_matching_transaction
-      sample = sample_with(:transaction_name => MATCHING_TRANSACTION)
-      @buffer.store(sample)
-      assert_equal([sample], @buffer.samples)
-    end
-    def test_stores_and_marks_xray_session_id
-      sample = sample_with(:transaction_name => MATCHING_TRANSACTION)
-      @buffer.store(sample)
-      assert_equal(XRAY_SESSION_ID, sample.xray_session_id)
-    end
-    def test_limits_xray_traces
-      tons_o_samples = max_samples * 2
-      samples = (0..tons_o_samples).map do |i|
-        sample = sample_with(:transaction_name => MATCHING_TRANSACTION)
-        @buffer.store(sample)
-        sample
-      end
-      assert_equal(samples.first(max_samples), @buffer.samples)
-    end
-    def test_can_disable_via_config
-      with_config(:'xray_session.allow_traces' => false) do
-        assert_false @buffer.enabled?
-      end
-    end
-    def max_samples
-      NewRelic::Agent.config[:'xray_session.max_samples']
-    end
-    def sample_with(opts={})
-      sample = NewRelic::Agent::Transaction::Trace.new(Time.now)
-      sample.transaction_name = opts[:transaction_name]
-      sample
-    end
-  end
-end

data/test/new_relic/agent/transaction_error_primitive_test.rb DELETED Viewed

@@ -1,117 +0,0 @@
-# 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/attribute_filter'
-require 'new_relic/agent/transaction/attributes'
-require 'new_relic/agent/transaction_error_primitive'
-module NewRelic
-  module Agent
-    class TransactionErrorPrimitiveTest < Minitest::Test
-      def setup
-        freeze_time
-      end
-      def test_event_includes_expected_intrinsics
-        intrinsics, *_ = create_event
-        assert_equal 'TransactionError', intrinsics['type']
-        assert_in_delta Time.now.to_f, intrinsics['timestamp'], 0.001
-        assert_equal "RuntimeError", intrinsics['error.class']
-        assert_equal "Big Controller!", intrinsics['error.message']
-        assert_equal "Controller/blogs/index", intrinsics['transactionName']
-        assert_equal 0.1, intrinsics['duration']
-        assert_equal 80, intrinsics['port']
-      end
-      def test_event_includes_synthetics
-        intrinsics, *_ = create_event :payload_options => {
-          :synthetics_resource_id=>3,
-          :synthetics_job_id=>4,
-          :synthetics_monitor_id=>5
-        }
-        assert_equal 3, intrinsics['nr.syntheticsResourceId']
-        assert_equal 4, intrinsics['nr.syntheticsJobId']
-        assert_equal 5, intrinsics['nr.syntheticsMonitorId']
-      end
-      def test_includes_mapped_metrics
-        metrics = NewRelic::Agent::TransactionMetrics.new
-        metrics.record_unscoped 'Datastore/all', 10
-        metrics.record_unscoped 'GC/Transaction/all', 11
-        metrics.record_unscoped 'WebFrontend/QueueTime', 12
-        metrics.record_unscoped 'External/allWeb', 13
-        intrinsics, *_ = create_event :payload_options => {:metrics => metrics}
-        assert_equal 10.0, intrinsics["databaseDuration"]
-        assert_equal 1, intrinsics["databaseCallCount"]
-        assert_equal 11.0, intrinsics["gcCumulative"]
-        assert_equal 12.0, intrinsics["queueDuration"]
-        assert_equal 13.0, intrinsics["externalDuration"]
-        assert_equal 1, intrinsics["externalCallCount"]
-      end
-      def test_includes_cat_attributes
-        intrinsics, *_ = create_event :payload_options => {:guid => "GUID", :referring_transaction_guid=>"REFERRING_GUID"}
-        assert_equal "GUID", intrinsics["nr.transactionGuid"]
-        assert_equal "REFERRING_GUID", intrinsics["nr.referringTransactionGuid"]
-      end
-      def test_includes_custom_attributes
-        attrs = {"user" => "Wes Mantooth", "channel" => 9}
-        attributes = Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-        attributes.merge_custom_attributes attrs
-        _, custom_attrs, _ = create_event :error_options => {:attributes => attributes}
-        assert_equal attrs, custom_attrs
-      end
-      def test_includes_agent_attributes
-        attributes = Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-        attributes.add_agent_attribute :'request.headers.referer', "http://blog.site/home", AttributeFilter::DST_ERROR_COLLECTOR
-        attributes.add_agent_attribute :httpResponseCode, "200", AttributeFilter::DST_ERROR_COLLECTOR
-        _, _, agent_attrs = create_event :error_options => {:attributes => attributes}
-        expected = {:"request.headers.referer" => "http://blog.site/home", :httpResponseCode => "200"}
-        assert_equal expected, agent_attrs
-      end
-      def create_event options = {}
-        payload = generate_payload options[:payload_options] || {}
-        error = create_noticed_error options[:error_options] || {}
-        TransactionErrorPrimitive.create error, payload
-      end
-      def generate_payload options = {}
-        {
-          :name => "Controller/blogs/index",
-          :type => :controller,
-          :start_timestamp => Time.now.to_f,
-          :duration => 0.1
-        }.update(options)
-      end
-      def create_noticed_error options = {}
-        exception = options.delete(:exception) || RuntimeError.new("Big Controller!")
-        txn_name = "Controller/blogs/index"
-        noticed_error = NewRelic::NoticedError.new(txn_name, exception)
-        noticed_error.request_uri = "http://site.com/blogs"
-        noticed_error.request_port = 80
-        noticed_error.attributes  = options.delete(:attributes)
-        noticed_error.attributes_from_notice_error = options.delete(:custom_params) || {}
-        noticed_error.attributes_from_notice_error.merge!(options)
-        noticed_error
-      end
-    end
-  end
-end

data/test/new_relic/agent/transaction_event_aggregator_test.rb DELETED Viewed

@@ -1,211 +0,0 @@
-# -*- ruby -*-
-# 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 File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
-require 'new_relic/agent/transaction_event_aggregator'
-require 'new_relic/agent/transaction/attributes'
-require 'new_relic/agent/transaction_event_primitive'
-module NewRelic
-  module Agent
-    class TransactionEventAggregatorTest < Minitest::Test
-      def setup
-        freeze_time
-        @event_aggregator = TransactionEventAggregator.new
-        @attributes = nil
-      end
-      # Helpers for DataContainerTests
-      def create_container
-        @event_aggregator
-      end
-      def populate_container(sampler, n)
-        n.times do |i|
-          generate_request("whatever#{i}")
-        end
-      end
-      include NewRelic::DataContainerTests
-      # Tests
-      def test_samples_on_transaction_finished_event
-        generate_request
-        assert_equal 1, last_transaction_events.length
-      end
-      def test_records_background_tasks
-        generate_request('a', :type => :controller)
-        generate_request('b', :type => :background)
-        assert_equal 2, last_transaction_events.size
-      end
-      def test_can_disable_sampling_for_analytics
-        with_config( :'analytics_events.enabled' => false ) do
-          generate_request
-          assert last_transaction_events.empty?
-        end
-      end
-      def test_harvest_returns_previous_sample_list
-        5.times { generate_request }
-        _, old_samples = @event_aggregator.harvest!
-        assert_equal 5, old_samples.size
-        assert_equal 0, last_transaction_events.size
-      end
-      def test_merge_merges_samples_back_into_buffer
-        5.times { generate_request }
-        old_samples = @event_aggregator.harvest!
-        5.times { generate_request }
-        @event_aggregator.merge!(old_samples)
-        assert_equal(10, last_transaction_events.size)
-      end
-      def test_merge_abides_by_max_samples_limit
-        with_config(:'analytics_events.max_samples_stored' => 5) do
-          4.times { generate_request }
-          old_samples = @event_aggregator.harvest!
-          4.times { generate_request }
-          @event_aggregator.merge!(old_samples)
-          assert_equal(5, last_transaction_events.size)
-        end
-      end
-      def test_sample_counts_are_correct_after_merge
-        with_config :'analytics_events.max_samples_stored' => 5 do
-          buffer = @event_aggregator.instance_variable_get :@buffer
-          4.times { generate_request }
-          last_harvest = @event_aggregator.harvest!
-          assert_equal 4, buffer.seen_lifetime
-          assert_equal 4, buffer.captured_lifetime
-          assert_equal 4, last_harvest[0][:events_seen]
-          4.times { generate_request }
-          @event_aggregator.merge! last_harvest
-          reservoir_stats, samples = @event_aggregator.harvest!
-          assert_equal 5, samples.size
-          assert_equal 8, reservoir_stats[:events_seen]
-          assert_equal 8, buffer.seen_lifetime
-          assert_equal 5, buffer.captured_lifetime
-        end
-      end
-      def test_limits_total_number_of_samples_to_max_samples_stored
-        with_config( :'analytics_events.max_samples_stored' => 100 ) do
-          150.times { generate_request }
-          assert_equal 100, last_transaction_events.size
-        end
-      end
-      def test_resets_limits_on_harvest
-        with_config( :'analytics_events.max_samples_stored' => 100 ) do
-          50.times { generate_request('before') }
-          samples_before = last_transaction_events
-          assert_equal 50, samples_before.size
-          150.times { generate_request('after') }
-          samples_after = last_transaction_events
-          assert_equal 100, samples_after.size
-          assert_equal 0, (samples_before & samples_after).size
-        end
-      end
-      def test_does_not_drop_samples_when_used_from_multiple_threads
-        with_config( :'analytics_events.max_samples_stored' => 100 * 100 ) do
-          threads = []
-          25.times do
-            threads << Thread.new do
-              100.times { generate_request }
-            end
-          end
-          threads.each { |t| t.join }
-          assert_equal(25 * 100, last_transaction_events.size)
-        end
-      end
-      def test_append_accepts_a_block
-        payload = generate_payload
-        @event_aggregator.append { TransactionEventPrimitive.create(payload) }
-        assert_equal 1, last_transaction_events.size
-      end
-      def test_block_is_not_executed_unless_buffer_admits_event
-        event = nil
-        with_config :'analytics_events.max_samples_stored' => 5 do
-          5.times { generate_request }
-          #cause sample to be discarded by the sampled buffer
-          buffer = @event_aggregator.instance_variable_get :@buffer
-          buffer.stubs(:rand).returns(6)
-          payload = generate_payload
-          @event_aggregator.append do
-            event = TransactionEventPrimitive.create(payload)
-          end
-        end
-        assert_nil event, "Did not expect block to be executed"
-        refute_includes last_transaction_events, event
-      end
-      #
-      # Helpers
-      #
-      def generate_request(name='whatever', options={})
-        payload = generate_payload name, options
-        @event_aggregator.append TransactionEventPrimitive.create(payload)
-      end
-      def generate_payload(name='whatever', options={})
-        {
-          :name => "Controller/#{name}",
-          :type => :controller,
-          :start_timestamp => options[:timestamp] || Time.now.to_f,
-          :duration => 0.1,
-          :attributes => attributes,
-          :error => false
-        }.merge(options)
-      end
-      def attributes
-        if @attributes.nil?
-          filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
-          @attributes = NewRelic::Agent::Transaction::Attributes.new(filter)
-        end
-        @attributes
-      end
-      def last_transaction_events
-        @event_aggregator.harvest![1]
-      end
-      def last_transaction_event
-        events = last_transaction_events
-        assert_equal 1, events.size
-        events.first
-      end
-    end
-  end
-end