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/threading/fake_thread.rb DELETED Viewed

@@ -1,43 +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.
-class FakeThread
-  @@list = []
-  def initialize(locals={}, &block)
-    @locals = locals
-    yield if block_given?
-  end
-  def self.current
-    {}
-  end
-  def self.list
-    @@list
-  end
-  def alive?
-    true
-  end
-  def key?(key)
-    @locals.key?(key)
-  end
-  def [](key)
-    @locals[key]
-  end
-  def []=(key, value)
-    @locals[key] = value
-  end
-  def backtrace
-    @locals[:backtrace] || []
-  end
-  def join
-  end
-end

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

@@ -1,271 +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/threading/backtrace_service'
-require 'new_relic/agent/threading/thread_profile'
-require 'new_relic/agent/threading/threaded_test_case'
-if NewRelic::Agent::Threading::BacktraceService.is_supported?
-  module NewRelic::Agent::Threading
-    class ThreadProfileTest < Minitest::Test
-      include ThreadedTestCase
-      def setup
-        setup_fake_threads
-        @single_trace = [
-          "irb.rb:69:in `catch'",
-          "irb.rb:69:in `start'",
-          "irb:12:in `<main>'"
-        ]
-        @profile = ThreadProfile.new
-        # Run the worker_loop for the thread profile based on two iterations
-        # This takes time fussiness out of the equation and keeps the tests stable
-        @profile.instance_variable_set(:@worker_loop, NewRelic::Agent::WorkerLoop.new(:limit => 2))
-      end
-      def teardown
-        teardown_fake_threads
-      end
-      def target_for_shared_client_tests
-        @profile
-      end
-      def test_prune_tree
-        @profile.aggregate(@single_trace, :request, Thread.current)
-        @profile.convert_N_trace_nodes_to_arrays(1)
-        assert_equal 1, count_backtrace_nodes(@profile.traces[:request])
-      end
-      def test_prune_keeps_highest_counts
-        @profile.aggregate(@single_trace, :request, Thread.current)
-        @profile.aggregate(@single_trace, :other  , Thread.current)
-        @profile.aggregate(@single_trace, :other  , Thread.current)
-        @profile.convert_N_trace_nodes_to_arrays(1)
-        assert_equal 0, count_backtrace_nodes(@profile.traces[:request])
-        assert_equal 1, count_backtrace_nodes(@profile.traces[:other  ])
-      end
-      def test_prune_keeps_highest_count_then_depths
-        @profile.aggregate(@single_trace, :request, Thread.current)
-        @profile.aggregate(@single_trace, :other  , Thread.current)
-        @profile.convert_N_trace_nodes_to_arrays(2)
-        assert_equal 1, count_backtrace_nodes(@profile.traces[:request])
-        assert_equal 1, count_backtrace_nodes(@profile.traces[:other  ])
-      end
-      def build_well_known_trace(args={})
-        @profile = ThreadProfile.new(args)
-        thread = stub
-        trace = ["thread_profiler.py:1:in `<module>'"]
-        10.times { @profile.aggregate(trace, :other, thread) }
-        thread = stub
-        trace = [
-          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:489:in `__bootstrap'",
-          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:512:in `__bootstrap_inner'",
-          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:480:in `run'",
-          "thread_profiler.py:76:in `_profiler_loop'",
-          "thread_profiler.py:103:in `_run_profiler'",
-          "thread_profiler.py:165:in `collect_thread_stacks'"
-        ]
-        10.times { @profile.aggregate(trace, :agent, thread) }
-        @profile.increment_poll_count
-      end
-      WELL_KNOWN_TRACE_ENCODED = "eJy9klFPwjAUhf/LfW7WDQTUGBPUiYkGdAxelqXZRpGGrm1uS8xi/O924JQX\n9Un7dm77ndN7c19hlt7FCZxnWQZug7xYMYN6LSTHwDRA4KLWq53kl0CinEQh\nCUmW5zmBJH5axPPUk16MJ/E0/cGk0lLyyrGPS+uKamu943DQeX5HMtypz5In\nwv6vRCeZ1NoAGQ2PCDpvrOM1fRAlFtjQWyxq/qJxa+lj4zZaBeuuQpccrdDK\n0l4wolKU1OxftOoQLNTzIdL/EcjJafjnQYyVWjvrsDBMKNVOZBD1/jO27fPs\naBG+DoGr8fX9JJktpjftVry9A9unzGo=\n"
-      def test_to_collector_array
-        build_well_known_trace('profile_id' => 333)
-        @profile.stubs(:created_at).returns(1350403938892.524)
-        @profile.finished_at = 1350403939904.375
-        expected = [
-          333,
-          1350403938892.524,
-          1350403939904.375,
-          1,
-          WELL_KNOWN_TRACE_ENCODED,
-          2,
-          0
-        ]
-        assert_equal expected, @profile.to_collector_array(encoder)
-      end
-      def test_to_collector_array_with_identity_encoder
-        build_well_known_trace('profile_id' => 333)
-        @profile.stubs(:created_at).returns(12)
-        @profile.finished_at = 13
-        expected = [
-          333,
-          12,
-          13,
-          1,
-          @profile.generate_traces,
-          2,
-          0
-        ]
-        assert_equal expected, @profile.to_collector_array(NewRelic::Agent::NewRelicService::Encoders::Identity)
-      end
-      def test_to_collector_array_with_xray_session_id
-        build_well_known_trace('profile_id' => -1, 'x_ray_id' => 4242)
-        @profile.stubs(:created_at).returns(1350403938892.524)
-        @profile.finished_at = 1350403939904.375
-        expected = [
-          -1,
-          1350403938892.524,
-          1350403939904.375,
-          20,
-          WELL_KNOWN_TRACE_ENCODED,
-          2,
-          0,
-          4242
-        ]
-        assert_equal expected, @profile.to_collector_array(encoder)
-      end
-      def test_to_collector_array_with_bad_values
-        build_well_known_trace(:profile_id => -1)
-        @profile.stubs(:created_at).returns('')
-        @profile.finished_at = nil
-        @profile.instance_variable_set(:@poll_count, Rational(10, 1))
-        @profile.instance_variable_set(:@backtrace_count, nil)
-        @profile.instance_variable_set(:@unique_threads, nil)
-        expected = [
-          -1,
-          0.0,
-          0.0,
-          10,
-          WELL_KNOWN_TRACE_ENCODED,
-          0,
-          0
-        ]
-        assert_equal expected, @profile.to_collector_array(encoder)
-      end
-      def test_aggregate_should_increment_only_backtrace_count
-        backtrace_count = @profile.backtrace_count
-        failure_count = @profile.failure_count
-        @profile.aggregate(@single_trace, :request, Thread.current)
-        assert_equal backtrace_count + 1, @profile.backtrace_count
-        assert_equal failure_count, @profile.failure_count
-      end
-      def test_aggregate_increments_only_the_failure_count_with_nil_backtrace
-        backtrace_count = @profile.backtrace_count
-        failure_count = @profile.failure_count
-        @profile.aggregate(nil, :request, Thread.current)
-        assert_equal backtrace_count, @profile.backtrace_count
-        assert_equal failure_count + 1, @profile.failure_count
-      end
-      def test_aggregate_updates_created_at_timestamp
-        expected = freeze_time
-        @profile = ThreadProfile.new
-        @profile.aggregate(@single_trace, :request, Thread.current)
-        t0 = @profile.created_at
-        advance_time(5.0)
-        @profile.aggregate(@single_trace, :request, Thread.current)
-        assert_equal expected, t0
-        assert_equal expected, @profile.created_at
-      end
-      def test_aggregate_keeps_unique_thread_count
-        thread0 = stub
-        thread1 = stub
-        @profile.aggregate(@single_trace, :request, thread0)
-        @profile.aggregate(@single_trace, :request, thread0)
-        @profile.aggregate(@single_trace, :request, thread1)
-        assert_equal 2, @profile.unique_thread_count
-      end
-      SAMPLE_COUNT_POSITION = 3
-      def test_sample_count_for_thread_profiling
-        profile = ThreadProfile.new('x_ray_id' => nil)
-        profile.increment_poll_count
-        result = profile.to_collector_array(encoder)
-        assert_equal 1, result[SAMPLE_COUNT_POSITION]
-      end
-      def test_sample_count_for_xrays
-        profile = ThreadProfile.new('x_ray_id' => 123)
-        profile.aggregate(@single_trace, :request, Thread.current)
-        result = profile.to_collector_array(encoder)
-        assert_equal 1, result[SAMPLE_COUNT_POSITION]
-      end
-      def test_empty
-        profile = ThreadProfile.new
-        assert profile.empty?
-      end
-      def test_not_empty
-        profile = ThreadProfile.new
-        profile.aggregate([], :request, Thread.current)
-        assert_false profile.empty?
-      end
-      def encoder
-        NewRelic::Agent::NewRelicService::JsonMarshaller.new.default_encoder
-      end
-      def count_backtrace_nodes(bt_node)
-        trees = bt_node.as_array
-        count = 0
-        trees.each do |tree|
-          count += rec_count_tree_nodes(tree)
-        end
-        count
-      end
-      def rec_count_tree_nodes(tree)
-        count = 1 # 1 for this node
-        children = tree[3]
-        children.each do |child|
-          count += rec_count_tree_nodes(child)
-        end
-        count
-      end
-    end
-  end
-end

data/test/new_relic/agent/threading/threaded_test_case.rb DELETED Viewed

@@ -1,18 +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 'new_relic/agent/threading/fake_thread'
-module ThreadedTestCase
-  def setup_fake_threads
-    @original_thread_class = NewRelic::Agent::Threading::AgentThread.backing_thread_class
-    NewRelic::Agent::Threading::AgentThread.backing_thread_class = FakeThread
-    FakeThread.list.clear
-  end
-  def teardown_fake_threads
-    NewRelic::Agent::Threading::AgentThread.backing_thread_class = @original_thread_class
-    FakeThread.list.clear
-  end
-end

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

@@ -1,184 +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/traced_method_stack'
-class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
-  def setup
-    @frame_stack = NewRelic::Agent::TracedMethodStack.new
-  end
-  def test_scope_overlap
-    freeze_time
-    in_transaction('orlando') do
-      self.class.trace_execution_scoped('disney') { advance_time(0.1) }
-    end
-    in_transaction('anaheim') do
-      self.class.trace_execution_scoped('disney') { advance_time(0.11) }
-    end
-    assert_metrics_recorded(
-      ['disney', 'orlando'] => {
-        :call_count      => 1,
-        :total_call_time => 0.1
-      },
-      ['disney', 'anaheim'] => {
-        :call_count      => 1,
-        :total_call_time => 0.11
-      },
-      'disney' => {
-        :call_count      => 2,
-        :total_call_time => 0.21
-      })
-  end
-  def test_children_time
-    state = NewRelic::Agent::TransactionState.tl_get
-    freeze_time
-    expected1 = @frame_stack.push_frame(state, :a)
-    advance_time(0.001)
-    t2 = Time.now
-    expected2 = @frame_stack.push_frame(state, :b)
-    advance_time(0.002)
-    t3 = Time.now
-    expected = @frame_stack.push_frame(state, :c)
-    advance_time(0.003)
-    scope = @frame_stack.pop_frame(state, expected, "metric c", Time.now.to_f)
-    t4 = Time.now
-    assert_equal 0, scope.children_time
-    advance_time(0.001)
-    t5 = Time.now
-    expected = @frame_stack.push_frame(state, :d)
-    advance_time(0.002)
-    scope = @frame_stack.pop_frame(state, expected, "metric d", Time.now.to_f)
-    t6 = Time.now
-    assert_equal 0, scope.children_time
-    scope = @frame_stack.pop_frame(state, expected2, "metric b", Time.now.to_f)
-    assert_equal 'metric b', scope.name
-    assert_in_delta((t4 - t3) + (t6 - t5), scope.children_time, 0.0001)
-    scope = @frame_stack.pop_frame(state, expected1, "metric a", Time.now.to_f)
-    assert_equal scope.name, 'metric a'
-    assert_in_delta((t6 - t2), scope.children_time, 0.0001)
-  end
-  # test for when the scope stack contains an element only used for tts and not metrics
-  def test_simple_tt_only_scope
-    state = NewRelic::Agent::TransactionState.tl_get
-    node1 = @frame_stack.push_frame(state, :a, 0)
-    node2 = @frame_stack.push_frame(state, :b, 10)
-    node3 = @frame_stack.push_frame(state, :c, 20)
-    @frame_stack.pop_frame(state, node3, "name a", 30)
-    @frame_stack.pop_frame(state, node2, "name b", 20)
-    @frame_stack.pop_frame(state, node1, "name c", 10)
-    assert_equal 0, node3.children_time
-    assert_equal 10, node2.children_time
-    assert_equal 10, node1.children_time
-    assert @frame_stack.empty?
-  end
-  def test_double_tt_only_scope
-    state = NewRelic::Agent::TransactionState.tl_get
-    node1 = @frame_stack.push_frame(state, :a,  0)
-    node2 = @frame_stack.push_frame(state, :b, 10)
-    node3 = @frame_stack.push_frame(state, :c, 20)
-    node4 = @frame_stack.push_frame(state, :d, 30)
-    @frame_stack.pop_frame(state, node4, "name d", 40)
-    @frame_stack.pop_frame(state, node3, "name c", 30)
-    @frame_stack.pop_frame(state, node2, "name b", 20)
-    @frame_stack.pop_frame(state, node1, "name a", 10)
-    assert_equal  0, node4.children_time.round
-    assert_equal 10, node3.children_time.round
-    assert_equal 10, node2.children_time.round
-    assert_equal 10, node1.children_time.round
-    assert @frame_stack.empty?
-  end
-  def test_clear
-    state = NewRelic::Agent::TransactionState.tl_get
-    @frame_stack.push_frame(state, :a)
-    @frame_stack.clear
-    assert_empty @frame_stack
-  end
-  def test_sampler_enabling
-    assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => true)
-    assert_sampler_enabled_with(false, :'transaction_tracer.enabled' => false)
-  end
-  def test_fetch_matching_frame_fetches_the_next_matching_frame
-    state = NewRelic::Agent::TransactionState.tl_get
-    frame = @frame_stack.push_frame(state, :a,  0)
-    result = @frame_stack.fetch_matching_frame(frame)
-    assert_equal :a, result.tag
-    assert_equal frame, result
-  end
-  def test_fetch_matching_frame_discards_mismatched_frames
-    state = NewRelic::Agent::TransactionState.tl_get
-    frame = @frame_stack.push_frame(state, :a,  0)
-    @frame_stack.push_frame(state, :b,  0)
-    result = @frame_stack.fetch_matching_frame(frame)
-    assert_equal :a, result.tag
-    assert_equal frame, result
-  end
-  def test_fetch_matching_frame_raises_an_error_if_no_match
-    state = NewRelic::Agent::TransactionState.tl_get
-    frame = @frame_stack.push_frame(state, :a,  0)
-    @frame_stack.fetch_matching_frame(frame)
-    error = assert_raises(RuntimeError) do
-      @frame_stack.fetch_matching_frame(frame)
-    end
-    assert_match(/not found/, error.message)
-  end
-  def test_fetch_matching_frame_logs_any_unexpected_frame_tags
-    state = NewRelic::Agent::TransactionState.tl_get
-    frame = @frame_stack.push_frame(state, :a,  0)
-    @frame_stack.push_frame(state, :unexpected,  0)
-    expects_logging(:info, includes("unexpected"))
-    @frame_stack.fetch_matching_frame(frame)
-  end
-  def assert_sampler_enabled_with(expected, opts={})
-    with_config(opts) do
-      assert_equal expected, @frame_stack.sampler_enabled?
-    end
-  end
-end