RubyGems - newrelic_rpm - Versions diffs - 4.0.0.332 → 6.13.1 - Mend

newrelic_rpm 4.0.0.332 → 6.13.1

Files changed (1193) hide show

data/test/new_relic/agent/synthetics_event_buffer_test.rb DELETED

@@ -1,54 +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/event_buffer_test_cases'
-require 'new_relic/agent/synthetics_event_buffer'
-module NewRelic::Agent
-  class SyntheticsEventBufferTest < Minitest::Test
-    include EventBufferTestCases
-    def buffer_class
-      SyntheticsEventBuffer
-    end
-    def create_event(timestamp)
-      [{"timestamp" => timestamp}, {}]
-    end
-    def test_append_with_reject_returns_rejected_item
-      buffer = buffer_class.new(5)
-      5.times do |i|
-        result, reject = buffer.append_with_reject(create_event(i))
-        refute_nil(result)
-        assert_nil(reject)
-      end
-      event = create_event(10)
-      result, reject = buffer.append_with_reject(event)
-      assert_nil result
-      assert_equal event, reject
-    end
-    def test_append_with_reject_bases_removal_on_timestamp
-      buffer = buffer_class.new(5)
-      last_event = nil
-      5.times do |i|
-        last_event = create_event(i + 10)
-        result = buffer.append(last_event)
-        assert(result)
-      end
-      event = create_event(1)
-      result, reject = buffer.append_with_reject(event)
-      assert_equal event, result
-      assert_equal last_event, reject
-    end
-  end
-end

data/test/new_relic/agent/synthetics_monitor_test.rb DELETED

@@ -1,93 +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/synthetics_monitor'
-module NewRelic::Agent
-  class SyntheticsMonitorTest < Minitest::Test
-    ENCODING_KEY_NOOP         = "\0"
-    TRUSTED_ACCOUNT_IDS       = [42,13]
-    VERSION_ID  = 1
-    ACCOUNT_ID  = 42
-    RESOURCE_ID = 100
-    JOB_ID      = 200
-    MONITOR_ID  = 300
-    BAD_ACCOUNT_ID = 7
-    BAD_VERSION_ID = 2
-    STANDARD_DATA = [ACCOUNT_ID, RESOURCE_ID, JOB_ID, MONITOR_ID]
-    def setup
-      @events  = EventListener.new
-      @monitor = SyntheticsMonitor.new(@events)
-      NewRelic::Agent.reset_config
-      @config = {
-        :encoding_key        => ENCODING_KEY_NOOP,
-        :trusted_account_ids => TRUSTED_ACCOUNT_IDS
-      }
-      NewRelic::Agent.config.add_config_for_testing(@config)
-      @events.notify(:finished_configuring)
-    end
-    def test_doesnt_record_synthetics_state_without_header
-      in_transaction do
-        @events.notify(:before_call, {})
-        assert_no_synthetics_payload
-      end
-    end
-    def test_doesnt_record_synthetics_if_incoming_request_higher_version
-      synthetics_payload = [BAD_VERSION_ID] + STANDARD_DATA
-      with_synthetics_headers(synthetics_payload) do
-        assert_no_synthetics_payload
-      end
-    end
-    def test_doesnt_record_synthetics_if_not_trusted_account
-      synthetics_payload = [VERSION_ID, BAD_ACCOUNT_ID] + STANDARD_DATA[1..-1]
-      with_synthetics_headers(synthetics_payload) do
-        assert_no_synthetics_payload
-      end
-    end
-    def test_doesnt_record_synthetics_if_data_too_short
-      synthetics_payload = [VERSION_ID, ACCOUNT_ID]
-      with_synthetics_headers(synthetics_payload) do
-        assert_no_synthetics_payload
-      end
-    end
-    def test_records_synthetics_state_from_header
-      key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY
-      synthetics_payload = [VERSION_ID] + STANDARD_DATA
-      with_synthetics_headers(synthetics_payload, key) do
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
-        assert_equal @last_encoded_header, txn.raw_synthetics_header
-        assert_equal synthetics_payload,   txn.synthetics_payload
-      end
-    end
-    def synthetics_header(payload, header_key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY)
-      @last_encoded_header = json_dump_and_encode(payload)
-      { header_key => @last_encoded_header }
-    end
-    def assert_no_synthetics_payload
-      assert_nil NewRelic::Agent::TransactionState.tl_get.current_transaction.synthetics_payload
-    end
-    def with_synthetics_headers(payload, header_key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY)
-      in_transaction do
-        @events.notify(:before_call, synthetics_header(payload, header_key))
-        yield
-      end
-    end
-  end
-end

data/test/new_relic/agent/system_info_test.rb DELETED

@@ -1,133 +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::SystemInfoTest < Minitest::Test
-  def setup
-    NewRelic::Agent.instance.stats_engine.clear_stats
-    @sysinfo = ::NewRelic::Agent::SystemInfo
-    @sysinfo.clear_processor_info
-  end
-  each_cross_agent_test :dir => 'proc_cpuinfo', :pattern => "*.txt" do |file|
-    if File.basename(file) =~ /^((\d+|X)pack_(\d+|X)core_(\d+|X)logical).txt$/
-      test_name = "test_#{$1}"
-      num_physical_packages  = $2.to_i
-      num_physical_cores     = $3.to_i
-      num_logical_processors = $4.to_i
-      num_physical_packages  = nil if num_physical_packages  < 1
-      num_physical_cores     = nil if num_physical_cores     < 1
-      num_logical_processors = nil if num_logical_processors < 1
-      define_method(test_name) do
-        cpuinfo = File.read(file)
-        info = @sysinfo.parse_cpuinfo(cpuinfo)
-        assert_equal(num_physical_packages , info[:num_physical_packages ])
-        assert_equal(num_physical_cores    , info[:num_physical_cores    ])
-        assert_equal(num_logical_processors, info[:num_logical_processors])
-      end
-    elsif File.basename(file) =~ /malformed/
-      define_method("test_#{File.basename(file)}") do
-        cpuinfo = File.read(file)
-        info = @sysinfo.parse_cpuinfo(cpuinfo)
-        assert_equal(nil, info[:num_physical_package])
-        assert_equal(nil, info[:num_physical_cores])
-        assert_equal(nil, info[:num_logical_processors])
-      end
-    else
-      fail "Bad filename: #{file}"
-    end
-  end
-  container_id_test_dir   = File.join(cross_agent_tests_dir, 'docker_container_id')
-  container_id_test_cases = load_cross_agent_test(File.join('docker_container_id', 'cases'))
-  container_id_test_cases.each do |test_case|
-    filename = test_case['filename']
-    basename = File.basename(filename, '.txt')
-    test_name = "test_container_id_#{basename}"
-    define_method(test_name) do
-      input = File.read(File.join(container_id_test_dir, filename))
-      container_id = @sysinfo.parse_docker_container_id(input)
-      message = "Parsed incorrect Docker container ID from #{filename}"
-      assert_equal(test_case['containerId'], container_id, message)
-      if test_case['expectedMetrics']
-        assert_metrics_recorded test_case['expectedMetrics']
-      else
-        refute_metrics_recorded "Supportability/utilization/docker/error"
-      end
-    end
-  end
-  each_cross_agent_test :dir => 'proc_meminfo', :pattern => '*.txt' do |file|
-    if File.basename(file) =~ /^meminfo_(\d+)MB.txt$/
-      test_name = "test_#{file}"
-      mem_total_expected = $1.to_f
-      define_method(test_name) do
-        meminfo = File.read(file)
-        mem_total_actual = @sysinfo.parse_linux_meminfo_in_mib(meminfo)
-        assert_equal(mem_total_expected, mem_total_actual)
-      end
-    else
-      fail "Bad filename: cross_agent_tests/proc_meminfo/#{file}"
-    end
-  end
-  def test_proc_meminfo_unparsable
-    assert_nil @sysinfo.parse_linux_meminfo_in_mib("")
-  end
-  def test_ram_in_mb_nil_when_proc_meminfo_unreadable
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
-    NewRelic::Agent::SystemInfo.expects(:proc_try_read).with('/proc/meminfo').returns(nil)
-    assert_nil NewRelic::Agent::SystemInfo.ram_in_mib, "Expected ram_in_mib to be nil"
-  end
-  def test_system_info_darwin_predicate
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
-    assert NewRelic::Agent::SystemInfo.darwin?, "Expected OS to match darwin"
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
-    refute NewRelic::Agent::SystemInfo.darwin?, "Did not expect OS to match darwin"
-  end
-  def test_system_info_linux_predicate
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
-    assert NewRelic::Agent::SystemInfo.linux?, "Expected OS to match linux"
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
-    refute NewRelic::Agent::SystemInfo.linux?, "Did not expect OS to match linux"
-  end
-  def test_system_info_bsd_predicate
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("freebsd")
-    assert NewRelic::Agent::SystemInfo.bsd?, "Expected OS to match bsd"
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
-    refute NewRelic::Agent::SystemInfo.bsd?, "Did not expect OS to match bsd"
-  end
-  def test_supportability_metric_recorded_when_docker_id_unavailable
-    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
-    cgroup_info = File.read File.join(cross_agent_tests_dir, 'docker_container_id', 'invalid-length.txt')
-    NewRelic::Agent::SystemInfo.expects(:proc_try_read).with('/proc/self/cgroup').returns(cgroup_info)
-    in_transaction('txn') do
-      assert_nil NewRelic::Agent::SystemInfo.docker_container_id
-    end
-    assert_metrics_recorded "Supportability/utilization/docker/error"
-  end
-end

data/test/new_relic/agent/threading/agent_thread_test.rb DELETED

@@ -1,149 +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/agent_thread'
-module NewRelic::Agent::Threading
-  class AgentThreadTest < Minitest::Test
-    def test_sets_label
-      t = AgentThread.create("labelled") {}
-      assert_equal "labelled", t[:newrelic_label]
-      t.join
-    end
-    def test_bucket_thread_as_agent_when_profiling
-      t = AgentThread.create("labelled") {}
-      assert_equal :agent, AgentThread.bucket_thread(t, true)
-      t.join
-    end
-    def test_bucket_thread_as_agent_when_not_profiling
-      t = AgentThread.create("labelled") {}
-      assert_equal :ignore, AgentThread.bucket_thread(t, false)
-      t.join
-    end
-    def test_bucket_thread_as_request
-      q0 = Queue.new
-      q1 = Queue.new
-      t = Thread.new do
-        begin
-          in_web_transaction do
-            q0.push 'unblock main thread'
-            q1.pop
-          end
-        rescue => e
-          q0.push 'unblock main thread'
-          fail e
-        end
-      end
-      q0.pop # wait until thread has had a chance to start up
-      assert_equal :request, AgentThread.bucket_thread(t, DONT_CARE)
-      q1.push 'unblock background thread'
-      t.join
-    end
-    def test_bucket_thread_as_background
-      q0 = Queue.new
-      q1 = Queue.new
-      t = ::Thread.new do
-        begin
-          in_transaction do
-            q0.push 'unblock main thread'
-            q1.pop
-          end
-        rescue => e
-          q0.push 'unblock main thread'
-          fail e
-        end
-      end
-      q0.pop # wait until thread pushes to q
-      assert_equal :background, AgentThread.bucket_thread(t, DONT_CARE)
-      q1.push 'unblock background thread'
-      t.join
-    end
-    def test_bucket_thread_as_other
-      t = ::Thread.new {}
-      assert_equal :other, AgentThread.bucket_thread(t, DONT_CARE)
-      t.join
-    end
-    def test_runs_block
-      called = false
-      t = AgentThread.create("labelled") { called = true }
-      t.join
-      assert called
-    end
-    def test_standard_error_is_caught
-      expects_logging(:error, includes("exited"), any_parameters)
-      t = AgentThread.create("fail") { raise "O_o" }
-      t.join
-      assert_thread_completed(t)
-    end
-    def test_exception_is_reraised
-      expects_logging(:error, includes("exited"), any_parameters)
-      assert_raises(Exception) do
-        begin
-          t = AgentThread.create("fail") { raise Exception.new }
-          t.join
-        ensure
-          assert_thread_died_from_exception(t)
-        end
-      end
-    end
-    def assert_thread_completed(t)
-      assert_equal false, t.status
-    end
-    def assert_thread_died_from_exception(t)
-      assert_equal nil, t.status
-    end
-    TRACE = [
-      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/eventmachine-0.12.10/lib/eventmachine.rb:100:in `catch'",
-      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/newrelic_rpm-3.5.3.452.dev/lib/new_relic/agent/agent.rb:200:in `start_worker_thread'",
-      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/thin-1.5.0/lib/thin/backends/base.rb:300:in `block (3 levels) in run'",
-    ]
-    def test_scrubs_backtrace_when_not_profiling_agent_code
-      result = AgentThread.scrub_backtrace(stub(:backtrace => TRACE.dup), false)
-      assert_equal [TRACE[0], TRACE[2]], result
-    end
-    def test_doesnt_scrub_backtrace_when_profiling_agent_code
-      result = AgentThread.scrub_backtrace(stub(:backtrace => TRACE.dup), true)
-      assert_equal TRACE, result
-    end
-    def test_scrub_backtrace_handles_errors_during_backtrace
-      dummy_thread = stub
-      dummy_thread.stubs(:backtrace).raises(StandardError.new('nah'))
-      AgentThread.scrub_backtrace(dummy_thread, true)
-    end
-    def test_scrub_backtrace_handles_nil_backtrace
-      bt = AgentThread.scrub_backtrace(stub(:backtrace => nil), false)
-      assert_nil(bt)
-    end
-    DONT_CARE = true
-  end
-end

data/test/new_relic/agent/threading/backtrace_node_test.rb DELETED

@@ -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/threading/backtrace_node'
-module NewRelic::Agent::Threading
-  class BacktraceNodeTest < Minitest::Test
-    SINGLE_LINE = "irb.rb:69:in `catch'"
-    def setup
-      @node = BacktraceRoot.new
-      @single_trace = [
-        "irb.rb:69:in `catch'",
-        "irb.rb:69:in `start'",
-        "irb:12:in `<main>'"
-      ]
-    end
-    def assert_backtrace_trees_equal(a, b, original_a=a, original_b=b)
-      message = "Thread profiles did not match.\n\n"
-      message << "Expected tree:\n#{original_a.dump_string}\n\n"
-      message << "Actual tree:\n#{original_b.dump_string}\n"
-      assert_equal(a, b, message)
-      assert_equal(a.children, b.children, message)
-      a.children.zip(b.children) do |a_child, b_child|
-        assert_backtrace_trees_equal(a_child, b_child, a, b)
-      end
-    end
-    def create_node(frame, parent=nil, runnable_count=0)
-      node = BacktraceNode.new(frame)
-      parent.add_child_unless_present(node) if parent
-      node.runnable_count = runnable_count
-      node
-    end
-    def convert_nodes_to_array(nodes)
-      nodes.each {|n| n.mark_for_array_conversion }
-      nodes.each {|n| n.complete_array_conversion }
-    end
-    def test_single_node_converts_to_array
-      line = "irb.rb:69:in `catch'"
-      node = BacktraceNode.new(line)
-      convert_nodes_to_array([node])
-      assert_equal([
-                   ["irb.rb", "catch", 69],
-                   0, 0,
-                   []],
-                   node.as_array)
-    end
-    def test_multiple_nodes_converts_to_array
-      line = "irb.rb:69:in `catch'"
-      child_line = "bacon.rb:42:in `yum'"
-      node = create_node(line)
-      child_node = create_node(child_line, node)
-      convert_nodes_to_array([node, child_node])
-      assert_equal([
-                   ["irb.rb", "catch", 69],
-                   0, 0,
-                   [
-                     [
-                       ['bacon.rb', 'yum', 42],
-                       0,0,
-                       []
-      ]
-      ]],
-        node.as_array)
-    end
-    def test_nodes_without_line_numbers
-      line = "transaction_sample_buffer.rb:in `visit_node'"
-      node = create_node(line)
-      convert_nodes_to_array([node])
-      assert_equal([
-                   ["transaction_sample_buffer.rb", "visit_node", -1],
-                   0, 0,
-                   []],
-                   node.as_array)
-    end
-    def test_gracefully_handle_bad_values_in_to_array
-      node = BacktraceNode.new(SINGLE_LINE)
-      node.stubs(:parse_backtrace_frame).returns(["irb.rb", "catch", "blarg"])
-      node.runnable_count = Rational(10, 1)
-      convert_nodes_to_array([node])
-      assert_equal([
-                   ["irb.rb", "catch", 0],
-                   10, 0,
-                   []],
-                   node.as_array)
-    end
-    def test_add_child_twice
-      parent = BacktraceNode.new(SINGLE_LINE)
-      child = BacktraceNode.new(SINGLE_LINE)
-      parent.add_child_unless_present(child)
-      parent.add_child_unless_present(child)
-      assert_equal 1, parent.children.size
-    end
-    def test_aggregate_builds_tree_from_first_trace
-      @node.aggregate(@single_trace)
-      root = BacktraceRoot.new
-      tree = create_node(@single_trace[-1], root, 1)
-      child = create_node(@single_trace[-2], tree, 1)
-      create_node(@single_trace[-3], child, 1)
-      assert_backtrace_trees_equal root, @node
-    end
-    def test_aggregate_builds_tree_from_overlapping_traces
-      @node.aggregate(@single_trace)
-      @node.aggregate(@single_trace)
-      root = BacktraceRoot.new
-      tree = create_node(@single_trace[-1], root, 2)
-      child = create_node(@single_trace[-2], tree, 2)
-      create_node(@single_trace[-3], child, 2)
-      assert_backtrace_trees_equal root, @node
-    end
-    def test_aggregate_builds_tree_from_diverging_traces
-      backtrace1 = [
-        "baz.rb:3:in `baz'",
-        "bar.rb:2:in `bar'",
-        "foo.rb:1:in `foo'"
-      ]
-      backtrace2 = [
-        "wiggle.rb:3:in `wiggle'",
-        "qux.rb:2:in `qux'",
-        "foo.rb:1:in `foo'"
-      ]
-      @node.aggregate(backtrace1)
-      @node.aggregate(backtrace2)
-      root = BacktraceRoot.new
-      tree = create_node(backtrace1.last, root, 2)
-      bar_node = create_node(backtrace1[1], tree, 1)
-      create_node(backtrace1[0], bar_node, 1)
-      qux_node = create_node(backtrace2[1], tree, 1)
-      create_node(backtrace2[0], qux_node, 1)
-      assert_backtrace_trees_equal(root, @node)
-    end
-    def test_aggregate_doesnt_create_duplicate_children
-      @node.aggregate(@single_trace)
-      @node.aggregate(@single_trace)
-      root = BacktraceRoot.new
-      tree = create_node(@single_trace[-1], root, 2)
-      child = create_node(@single_trace[-2], tree, 2)
-      create_node(@single_trace[-3], child, 2)
-      assert_backtrace_trees_equal(root, @node)
-    end
-    def test_aggregate_limits_recorded_depth
-      deep_backtrace = (0..2000).to_a.map { |i| "foo.rb:#{i}:in `foo'" }
-      root = BacktraceRoot.new
-      root.aggregate(deep_backtrace)
-      assert_equal(MAX_THREAD_PROFILE_DEPTH, root.flattened.size)
-    end
-  end
-end