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/commands/xray_session_collection_test.rb DELETED Viewed

@@ -1,332 +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/commands/xray_session_collection'
-module NewRelic::Agent::Commands
-  class XraySessionCollectionTest < Minitest::Test
-    attr_reader :sessions, :service
-    FIRST_ID = 123
-    FIRST_NAME = "Next Session"
-    FIRST_TRANSACTION_NAME = "Controller/blogs/index"
-    FIRST_REQUESTED_TRACE_COUNT = 10
-    FIRST_DURATION = 600
-    FIRST_SAMPLE_PERIOD = 0.2
-    FIRST_RUN_PROFILER = true
-    FIRST_METADATA  = {
-      "x_ray_id"              => FIRST_ID,
-      "xray_session_name"     => FIRST_NAME,
-      "key_transaction_name"  => FIRST_TRANSACTION_NAME,
-      "requested_trace_count" => FIRST_REQUESTED_TRACE_COUNT,
-      "duration"              => FIRST_DURATION,
-      "sample_period"         => FIRST_SAMPLE_PERIOD,
-      "run_profiler"          => FIRST_RUN_PROFILER,
-    }
-    SECOND_ID = 42
-    SECOND_TRANSACTION_NAME = "Controller/blogs/show"
-    SECOND_METADATA = {
-      "x_ray_id"             => SECOND_ID,
-      "key_transaction_name" => SECOND_TRANSACTION_NAME,
-      "duration"             => 0.0,
-      "run_profiler"         => true
-    }
-    ANOTHER_ID_FOR_SECOND = 666
-    ANOTHER_FOR_SECOND_METADATA = {
-      "x_ray_id"             => ANOTHER_ID_FOR_SECOND,
-      "key_transaction_name" => SECOND_TRANSACTION_NAME,
-      "duration"             => 0.0,
-      "run_profiler"         => true
-    }
-    def setup
-      @new_relic_service  = stub
-      NewRelic::Agent.instance.stubs(:service).returns(@new_relic_service)
-      @backtrace_service = NewRelic::Agent::Threading::BacktraceService.new
-      @backtrace_service.worker_loop.stubs(:run)
-      @event_listener = NewRelic::Agent::EventListener.new
-      @sessions = NewRelic::Agent::Commands::XraySessionCollection.new(@backtrace_service, @event_listener)
-      @new_relic_service.stubs(:get_xray_metadata).with([FIRST_ID]).returns([FIRST_METADATA])
-      @new_relic_service.stubs(:get_xray_metadata).with([SECOND_ID]).returns([SECOND_METADATA])
-      @new_relic_service.stubs(:get_xray_metadata).with([FIRST_ID, SECOND_ID]).returns([FIRST_METADATA, SECOND_METADATA])
-      @new_relic_service.stubs(:get_xray_metadata).with([ANOTHER_ID_FOR_SECOND]).returns([ANOTHER_FOR_SECOND_METADATA])
-    end
-    def teardown
-      @backtrace_service.worker_thread.join if @backtrace_service.worker_thread
-      NewRelic::Agent.instance.stats_engine.clear_stats
-    end
-    def test_can_add_sessions
-      handle_command_for(FIRST_ID, SECOND_ID)
-      assert sessions.include?(FIRST_ID)
-      assert sessions.include?(SECOND_ID)
-      assert_metrics_recorded({
-        "Supportability/XraySessions/Starts" => { :call_count => 2 }})
-    end
-    def test_can_disable_from_config
-      with_config(:'xray_session.enabled' => false) do
-        handle_command_for(FIRST_ID, SECOND_ID)
-        assert_false sessions.include?(FIRST_ID)
-        assert_false sessions.include?(SECOND_ID)
-      end
-    end
-    def test_adding_sessions_registers_them_as_thread_profiling_clients
-      xray_id = 333
-      xray_metadata = {
-        'x_ray_id'     => xray_id,
-        'run_profiler' => true,
-        'key_transaction_name' => 'foo'
-      }
-      @new_relic_service.stubs(:get_xray_metadata).with([xray_id]).returns([xray_metadata])
-      @backtrace_service.expects(:subscribe).with('foo', xray_metadata)
-      handle_command_for(xray_id)
-    end
-    def test_adding_sessions_does_not_register_them_as_thread_profiling_clients_unless_run_profiler_set
-      xray_id = 333
-      xray_metadata = {
-        'x_ray_id'     => xray_id,
-        'run_profiler' => false,
-        'key_transaction_name' => 'foo'
-      }
-      @new_relic_service.stubs(:get_xray_metadata).with([xray_id]).returns([xray_metadata])
-      @backtrace_service.expects(:subscribe).never
-      handle_command_for(xray_id)
-    end
-    def test_removing_sessions_unsubscribes_from_backtrace_service
-      xray_id = 333
-      xray_metadata = {
-        'x_ray_id'     => xray_id,
-        'run_profiler' => true,
-        'key_transaction_name' => 'foo'
-      }
-      @new_relic_service.stubs(:get_xray_metadata).with([xray_id]).returns([xray_metadata])
-      handle_command_for(xray_id)
-      @backtrace_service.expects(:unsubscribe).with('foo')
-      @sessions.handle_active_xray_sessions(create_agent_command('xray_ids' => []))
-    end
-    def test_creates_a_session_from_collector_metadata
-      handle_command_for(FIRST_ID)
-      session = sessions[FIRST_ID]
-      assert_equal FIRST_ID, session.id
-      assert_equal FIRST_NAME, session.xray_session_name
-      assert_equal FIRST_REQUESTED_TRACE_COUNT, session.requested_trace_count
-      assert_equal FIRST_DURATION, session.duration
-      assert_equal FIRST_SAMPLE_PERIOD, session.sample_period
-      assert_equal FIRST_RUN_PROFILER, session.run_profiler?
-      assert_equal FIRST_TRANSACTION_NAME, session.key_transaction_name
-      assert_equal true, session.active?
-    end
-    def test_defaults_out_properties_for_session_missing_metadata
-      handle_command_for(SECOND_ID)
-      session = sessions[SECOND_ID]
-      refute_nil session.xray_session_name
-      refute_nil session.requested_trace_count
-      refute_nil session.duration
-      refute_nil session.sample_period
-      refute_nil session.run_profiler?
-      refute_nil session.key_transaction_name
-      refute_nil session.active?
-    end
-    def test_doesnt_recall_metadata_for_already_active_sessions
-      # unstub fails on certain mocha/rails versions (rails23 env)
-      # replace the service instead to let us expect to never get the call...
-      @new_relic_service = stub
-      NewRelic::Agent.instance.stubs(:service).returns(@new_relic_service)
-      @new_relic_service.stubs(:get_xray_metadata).with([FIRST_ID]).returns([FIRST_METADATA])
-      @new_relic_service.stubs(:get_xray_metadata).with([SECOND_ID]).returns([SECOND_METADATA])
-      @new_relic_service.expects(:get_xray_metadata).with([FIRST_ID, SECOND_ID]).never
-      handle_command_for(FIRST_ID)
-      handle_command_for(FIRST_ID, SECOND_ID)
-      assert sessions.include?(FIRST_ID)
-      assert sessions.include?(SECOND_ID)
-    end
-    def test_adding_doesnt_replace_session_object
-      handle_command_for(FIRST_ID)
-      expected = sessions[FIRST_ID]
-      handle_command_for(FIRST_ID)
-      result = sessions[FIRST_ID]
-      assert_equal expected, result
-    end
-    def test_can_access_session
-      handle_command_for(FIRST_ID)
-      session = sessions[FIRST_ID]
-      assert_equal FIRST_ID, session.id
-    end
-    def test_can_find_session_id_by_transaction_name
-      handle_command_for(FIRST_ID)
-      result = sessions.session_id_for_transaction_name(FIRST_TRANSACTION_NAME)
-      assert_equal(FIRST_ID, result)
-    end
-    def test_can_find_session_id_by_missing_transaction_name
-      result = sessions.session_id_for_transaction_name("MISSING")
-      assert_nil result
-    end
-    def test_adding_a_session_actives_it
-      handle_command_for(FIRST_ID)
-      session = sessions[FIRST_ID]
-      assert_equal true, session.active?
-    end
-    def test_removes_inactive_sessions
-      handle_command_for(FIRST_ID, SECOND_ID)
-      handle_command_for(FIRST_ID)
-      assert_equal true, sessions.include?(FIRST_ID)
-      assert_equal false, sessions.include?(SECOND_ID)
-      assert_metrics_recorded(["Supportability/XraySessions/Stops"])
-    end
-    def test_removing_inactive_sessions_deactivates_them
-      handle_command_for(FIRST_ID)
-      session = sessions[FIRST_ID]
-      handle_command_for(*[])
-      assert_equal false, session.active?
-    end
-    def test_before_harvest_event_prunes_finished_sessions
-      freeze_time
-      handle_command_for(SECOND_ID)
-      assert sessions.include?(SECOND_ID)
-      advance_time(1.0)
-      @event_listener.notify(:before_harvest)
-      assert_false sessions.include?(SECOND_ID)
-    end
-    if NewRelic::Agent::Threading::BacktraceService.is_supported?
-      def test_harvest_thread_profiles_pulls_data_from_backtrace_service
-        handle_command_for(FIRST_ID, SECOND_ID)
-        profile0 = stub('profile0', :empty? => false)
-        profile1 = stub('profile1', :empty? => false)
-        @backtrace_service.expects(:harvest).with(FIRST_TRANSACTION_NAME).returns(profile0)
-        @backtrace_service.expects(:harvest).with(SECOND_TRANSACTION_NAME).returns(profile1)
-        profiles = @sessions.harvest_thread_profiles
-        assert_equal_unordered([profile0, profile1], profiles)
-      end
-      def test_harvest_thread_profiles_doesnt_return_empty_profiles
-        handle_command_for(FIRST_ID, SECOND_ID)
-        profile0 = stub('profile0', :empty? => true)
-        profile1 = stub('profile1', :empty? => false)
-        @backtrace_service.stubs(:harvest).with(FIRST_TRANSACTION_NAME).returns(profile0)
-        @backtrace_service.stubs(:harvest).with(SECOND_TRANSACTION_NAME).returns(profile1)
-        profiles = @sessions.harvest_thread_profiles
-        assert_equal_unordered([profile1], profiles)
-      end
-      def test_starting_and_stopping_for_same_transaction_in_one_call
-        # Don't run an actual thread--our shutdown on SECOND_ID leaves a thread
-        # that potentially tromples on other tests
-        @backtrace_service.stubs(:start)
-        handle_command_for(SECOND_ID)
-        assert_equal true, sessions.include?(SECOND_ID)
-        refute_nil @backtrace_service.profiles[SECOND_TRANSACTION_NAME]
-        handle_command_for(ANOTHER_ID_FOR_SECOND)
-        assert_equal false, sessions.include?(SECOND_ID)
-        assert_equal true, sessions.include?(ANOTHER_ID_FOR_SECOND)
-        refute_nil @backtrace_service.profiles[SECOND_TRANSACTION_NAME]
-      end
-      def test_concurrency_on_access_to_sessions
-        # Our usage in this test will spin up tons of threads when we pound
-        # the commands. Since we are only checking locking around @sessions,
-        # don't let the backtrace service spin up threads...
-        @backtrace_service.stubs(:subscribe)
-        harvest_thread = Thread.new do
-          Thread.current.abort_on_exception = true
-          500.times do
-            handle_command_for(FIRST_ID)
-            handle_command_for()
-          end
-        end
-        500.times do
-          sessions.session_id_for_transaction_name(FIRST_TRANSACTION_NAME)
-        end
-        harvest_thread.join
-        assert_nil @backtrace_service.worker_thread
-      end
-    else
-      def test_harvest_is_empty_if_not_supported
-        handle_command_for(FIRST_ID, SECOND_ID)
-        @backtrace_service.expects(:harvest).never
-        profiles = @sessions.harvest_thread_profiles
-        assert_equal([], profiles)
-      end
-    end
-    # Helpers
-    def handle_command_for(*session_ids)
-      command = command_for(*session_ids)
-      sessions.handle_active_xray_sessions(command)
-    end
-    def command_for(*session_ids)
-      create_agent_command({ "xray_ids" => session_ids})
-    end
-  end
-end

data/test/new_relic/agent/commands/xray_session_test.rb DELETED Viewed

@@ -1,42 +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/commands/xray_session'
-module NewRelic::Agent::Commands
-  class XraySessionTest < Minitest::Test
-    def test_run_profiler
-      session = XraySession.new('run_profiler' => true)
-      assert session.run_profiler?
-    end
-    def test_run_profiler_respects_config
-      with_config(:'xray_session.allow_profiles' => false) do
-        session = XraySession.new('run_profiler' => true)
-        assert_false session.run_profiler?
-      end
-    end
-    def test_not_finished
-      freeze_time
-      session = XraySession.new({})
-      session.activate
-      assert_false session.finished?
-    end
-    def test_finished
-      freeze_time
-      session = XraySession.new('duration' => 1.0)
-      session.activate
-      advance_time(2.0)
-      assert session.finished?
-    end
-  end
-end

data/test/new_relic/agent/configuration/default_source_test.rb DELETED Viewed

@@ -1,229 +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/configuration/default_source'
-module NewRelic::Agent::Configuration
-  class DefaultSourceTest < Minitest::Test
-    def setup
-      @default_source = DefaultSource.new
-      @defaults = ::NewRelic::Agent::Configuration::DEFAULTS
-    end
-    def test_default_values_have_a_public_setting
-      @defaults.each do |config_setting, config_value|
-        refute_nil config_value[:public], "Config setting: #{config_setting}"
-      end
-    end
-    def test_default_values_have_types
-      @defaults.each do |config_setting, config_value|
-        refute_nil config_value[:type], "Config setting: #{config_setting}"
-      end
-    end
-    def test_default_values_have_descriptions
-      @defaults.each do |config_setting, config_value|
-        refute_nil config_value[:description]
-        assert config_value[:description].length > 0, "Config setting: #{config_setting}"
-      end
-    end
-    def test_declared_types_match_default_values
-      NewRelic::Control.instance.local_env.stubs(:discovered_dispatcher).returns(:unicorn)
-      @default_source.keys.each do |key|
-        config_value = fetch_config_value(key)
-        actual_type = get_config_value_class(config_value)
-        expected_type = @defaults[key][:type]
-        if @defaults[key][:allow_nil]
-          assertion = (NilClass === config_value) || (expected_type === config_value)
-          assert assertion, "Default value for #{key} should be NilClass or #{expected_type}, is #{actual_type}."
-        else
-          assertion = expected_type === config_value
-          assert assertion, "Default value for #{key} should be #{expected_type}, is #{actual_type}."
-        end
-      end
-    end
-    def test_default_values_maps_keys_to_their_default_values
-      default_values = @default_source.default_values
-      @defaults.each do |key, value|
-        assert_equal value[:default], default_values[key]
-      end
-    end
-    def test_config_search_paths_include_application_root
-      NewRelic::Control.instance.stubs(:root).returns('app_root')
-      paths = DefaultSource.config_search_paths.call
-      assert paths.any? { |p| p.include? 'app_root' }
-    end
-    def fetch_config_value(key)
-      accessor = key.to_sym
-      config = @default_source
-      if config.has_key?(accessor)
-        if config[accessor].respond_to?(:call)
-          value = config[accessor]
-          while value.respond_to?(:call)
-            value = config.instance_eval(&value)
-          end
-          return value
-        else
-          return config[accessor]
-        end
-      end
-      nil
-    end
-    def test_transform_for_returns_something_callable
-      transform = DefaultSource.transform_for(:'rules.ignore_url_regexes')
-      assert transform.respond_to?(:call)
-    end
-    def test_transform_for_returns_nil_for_settings_that_do_not_have_a_transform
-      assert_nil DefaultSource.transform_for(:ca_bundle_path)
-    end
-    def test_convert_to_list
-      result = DefaultSource.convert_to_list("Foo,Bar,Baz")
-      assert_equal ['Foo', 'Bar', 'Baz'], result
-    end
-    def test_convert_to_list_returns_original_argument_given_array
-      result = DefaultSource.convert_to_list(['Foo'])
-      assert_equal ['Foo'], result
-    end
-    def test_convert_to_list_raises_on_totally_wrong_object
-      assert_raises(ArgumentError) do
-        DefaultSource.convert_to_list(Object.new)
-      end
-    end
-    def test_rules_ignore_converts_comma_delimited_string_to_array
-      with_config(:'rules.ignore_url_regexes' => 'Foo,Bar,Baz') do
-        assert_equal [/Foo/, /Bar/, /Baz/], NewRelic::Agent.config[:'rules.ignore_url_regexes']
-      end
-    end
-    def test_config_search_paths_with_home
-      with_environment("HOME" => "/home") do
-        paths = DefaultSource.config_search_paths.call()
-        assert_includes paths, "/home/.newrelic/newrelic.yml"
-        assert_includes paths, "/home/newrelic.yml"
-      end
-    end
-    def test_config_search_path_in_warbler
-      with_environment("GEM_HOME" => "/some/path.jar!") do
-        assert_includes DefaultSource.config_search_paths.call(), "/some/path.jar!/path/config/newrelic.yml"
-      end
-    end
-    def test_transaction_tracer_attributes_enabled_default
-      with_config(:'transaction_tracer.capture_attributes' => :foo) do
-        assert_equal :foo, NewRelic::Agent.config['transaction_tracer.attributes.enabled']
-      end
-    end
-    def test_transaction_events_attributes_enabled_default
-      with_config(:'analytics_events.capture_attributes' => :foo) do
-        assert_equal :foo, NewRelic::Agent.config['transaction_events.attributes.enabled']
-      end
-    end
-    def test_error_collector_attributes_enabled_default
-      with_config(:'error_collector.capture_attributes' => :foo) do
-        assert_equal :foo, NewRelic::Agent.config['error_collector.attributes.enabled']
-      end
-    end
-    def test_browser_monitoring_attributes_enabled_default
-      with_config(:'browser_monitoring.capture_attributes' => :foo) do
-        assert_equal :foo, NewRelic::Agent.config['browser_monitoring.attributes.enabled']
-      end
-    end
-    def test_agent_attribute_settings_convert_comma_delimited_strings_into_an_arrays
-      types = %w(transaction_tracer. transaction_events. error_collector. browser_monitoring.)
-      types << ''
-      types.each do |type|
-        key = "#{type}attributes.exclude".to_sym
-        with_config(key => 'foo,bar,baz') do
-          expected = ["foo", "bar", "baz"]
-          result = NewRelic::Agent.config[key]
-          message = "Expected #{key} to convert comma delimited string into array.\nExpected: #{expected.inspect}, Result: #{result.inspect}\n"
-          assert expected == result, message
-        end
-        key = "#{type}attributes.include".to_sym
-        with_config(key => 'foo,bar,baz') do
-          assert_equal ["foo", "bar", "baz"], NewRelic::Agent.config[key]
-        end
-      end
-    end
-    def test_agent_attributes_settings_with_yaml_array
-      types = %w(transaction_tracer. transaction_events. error_collector. browser_monitoring.)
-      types << ''
-      types.each do |type|
-        key = "#{type}attributes.exclude".to_sym
-        with_config(key => ['foo','bar','baz']) do
-          expected = ["foo", "bar", "baz"]
-          result = NewRelic::Agent.config[key]
-          message = "Expected #{key} not to modify settings from YAML array.\nExpected: #{expected.inspect}, Result: #{result.inspect}\n"
-          assert expected == result, message
-        end
-        key = "#{type}attributes.include".to_sym
-        with_config(key => 'foo,bar,baz') do
-          assert_equal ["foo", "bar", "baz"], NewRelic::Agent.config[key]
-        end
-      end
-    end
-    def test_all_settings_specify_whether_they_are_allowed_from_server
-      unspecified_keys = []
-      bad_value_keys = []
-      @defaults.each do |key, spec|
-        if !spec.has_key?(:allowed_from_server)
-          unspecified_keys << key
-        end
-        if ![true, false].include?(spec[:allowed_from_server])
-          bad_value_keys << key
-        end
-      end
-      assert unspecified_keys.empty?, "The following keys did not specify a value for :allowed_from_server: #{unspecified_keys.join(', ')}"
-      assert bad_value_keys.empty?, "The following keys had incorrect :allowed_from_server values (only true or false are allowed): #{bad_value_keys.join(', ')}"
-    end
-    def get_config_value_class(value)
-      type = value.class
-      if type == TrueClass || type == FalseClass
-        Boolean
-      else
-        type
-      end
-    end
-  end
-end