sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/agent/busy_calculator_test.rb

@@ -0,0 +1,96 @@
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
+  attr_reader :now
+  def setup
+    @now = Time.now.to_f
+    NewRelic::Agent::BusyCalculator.reset
+    @instance_busy = NewRelic::Agent::Stats.new
+    NewRelic::Agent::BusyCalculator.stubs(:instance_busy_stats).returns(@instance_busy)
+  end
+
+  def test_normal
+    # start the timewindow 10 seconds ago
+    # start a request at 10 seconds, 5 seconds long
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 5.0)
+    assert_equal 5, NewRelic::Agent::BusyCalculator.accumulator
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_split
+    # start the timewindow 10 seconds ago
+    # start a request at 5 seconds, don't finish
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count, @instance_busy
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_reentrancy
+    # start the timewindow 10 seconds ago
+    # start a request at 5 seconds, don't finish, but make two more
+    # complete calls, which should be ignored.
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.5)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.5)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 2.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 1.0)
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_concurrency
+    # start the timewindow 10 seconds ago
+    # start a request at 10 seconds, 5 seconds long
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 8.0)
+    worker = Thread.new do
+      # Get busy for 6 - 3 seconds
+      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 6.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 4.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
+    end
+    # Get busy for 8 - 2 seconds
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 2.0)
+    worker.join
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    # 3 + 6 = 9, or 90%
+    assert_in_delta 0.90, @instance_busy.total_call_time, 0.1
+
+  end
+  def test_dont_ignore_zero_counts
+    assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    assert_equal 3, @instance_busy.call_count
+  end
+  def test_can_turn_off_recording
+    with_config(:report_instance_busy => false) do
+      assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
+      NewRelic::Agent::BusyCalculator.harvest_busy
+      assert_equal 0, @instance_busy.call_count
+    end
+  end
+
+  def test_finishing_without_starting_doesnt_raise
+    Thread.current[:busy_entries] = nil
+    assert_nothing_raised do
+      NewRelic::Agent::BusyCalculator.dispatcher_finish
+    end
+  end
+
+end

data/test/new_relic/agent/configuration/environment_source_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/environment_source'
+
+module NewRelic::Agent::Configuration
+  class EnvironmentSourceTest < Test::Unit::TestCase
+
+    def setup
+      @original_env = {}
+      @original_env.replace(ENV)
+    end
+
+    def teardown
+      ENV.replace(@original_env)
+    end
+
+    def test_environment_strings_are_applied
+      assert_applied_string 'NRCONFIG', 'config_path'
+      assert_applied_string 'NEW_RELIC_LICENSE_KEY', 'license_key'
+      assert_applied_string 'NEWRELIC_LICENSE_KEY', 'license_key'
+      assert_applied_string 'NEW_RELIC_APP_NAME', 'app_name'
+      assert_applied_string 'NEWRELIC_APP_NAME', 'app_name'
+      assert_applied_string 'NEW_RELIC_HOST', 'host'
+      assert_applied_string 'NEW_RELIC_PORT', 'port'
+    end
+
+    def test_environment_symbols_are_applied
+      assert_applied_symbol 'NEW_RELIC_DISPATCHER', 'dispatcher'
+      assert_applied_symbol 'NEWRELIC_DISPATCHER', 'dispatcher'
+      assert_applied_symbol 'NEW_RELIC_FRAMEWORK', 'framework'
+      assert_applied_symbol 'NEWRELIC_FRAMEWORK', 'framework'
+    end
+
+    def test_environment_booleans_truths_are_applied
+      ENV['NEWRELIC_ENABLE'] = 'true'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'on'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'yes'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV.delete('NEWRELIC_ENABLE')
+    end
+
+    def test_environment_booleans_falsehoods_are_applied
+      ENV['NEWRELIC_ENABLE'] = 'false'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'off'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'no'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV.delete('NEWRELIC_ENABLE')
+    end
+
+    def test_set_log_config_from_environment
+      ENV['NEW_RELIC_LOG'] = 'off/in/space.log'
+      source = EnvironmentSource.new
+      assert_equal 'off/in', source[:log_file_path]
+      assert_equal 'space.log', source[:log_file_name]
+    end
+
+    def test_set_log_config_STDOUT_from_environment
+      ENV['NEW_RELIC_LOG'] = 'STDOUT'
+      source = EnvironmentSource.new
+      assert_equal 'STDOUT', source[:log_file_name]
+      assert_equal 'STDOUT', source[:log_file_path]
+    end
+
+    def assert_applied_string(env_var, config_var)
+      ENV[env_var] = 'test value'
+      assert_equal 'test value', EnvironmentSource.new[config_var.to_sym]
+      ENV.delete(env_var)
+    end
+
+    def assert_applied_symbol(env_var, config_var)
+      ENV[env_var] = 'test value'
+      assert_equal :'test value', EnvironmentSource.new[config_var.to_sym]
+      ENV.delete(env_var)
+    end
+  end
+end

data/test/new_relic/agent/configuration/manager_test.rb

@@ -0,0 +1,232 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/manager'
+require 'new_relic/agent/configuration/mask_defaults'
+
+module NewRelic::Agent::Configuration
+  class ManagerTest < Test::Unit::TestCase
+    def setup
+      @manager = NewRelic::Agent::Configuration::Manager.new
+    end
+
+    def test_should_use_indifferent_access
+      config = NewRelic::Agent::Configuration::DottedHash.new('string' => 'string', :symbol => 'symbol')
+      @manager.apply_config(config)
+      assert_equal 'string', @manager[:string]
+      assert_equal 'symbol', @manager['symbol']
+      @manager.remove_config(config)
+    end
+
+    def test_should_apply_config_sources_in_order
+      config0 = {
+        :foo => 'default foo',
+        :bar => 'default bar',
+        :baz => 'default baz'
+      }
+      @manager.apply_config(config0)
+      config1 = { :foo => 'real foo' }
+      @manager.apply_config(config1)
+      config2 = { :foo => 'wrong foo', :bar => 'real bar' }
+      @manager.apply_config(config2, 1)
+
+      assert_equal 'real foo', @manager['foo']
+      assert_equal 'real bar', @manager['bar']
+      assert_equal 'default baz', @manager['baz']
+
+      @manager.remove_config(config0)
+      @manager.remove_config(config1)
+      @manager.remove_config(config2)
+    end
+
+    def test_identifying_config_source
+      hash_source = {:foo => 'foo', :bar => 'default'}
+      @manager.apply_config(hash_source)
+      test_source = TestSource.new
+      test_source[:bar] = 'bar'
+      test_source[:baz] = 'baz'
+      @manager.apply_config(test_source)
+
+      assert_not_equal test_source, @manager.source(:foo)
+      assert_equal test_source, @manager.source(:bar)
+      assert_equal test_source, @manager.source(:baz)
+
+      @manager.remove_config(hash_source)
+      @manager.remove_config(test_source)
+    end
+
+    def test_callable_value_for_config_should_return_computed_value
+      source = {
+        :foo          => 'bar',
+        :simple_value => Proc.new { '666' },
+        :reference    => Proc.new { self['foo'] }
+      }
+      @manager.apply_config(source)
+
+      assert_equal 'bar', @manager[:foo]
+      assert_equal '666', @manager[:simple_value]
+      assert_equal 'bar', @manager[:reference]
+
+      @manager.remove_config(source)
+    end
+
+    def test_should_not_apply_removed_sources
+      test_source = TestSource.new
+      @manager.apply_config(test_source)
+      @manager.remove_config(test_source)
+
+      assert_equal nil, @manager['test_config_accessor']
+    end
+
+    def test_should_read_license_key_from_env
+      ENV['NEWRELIC_LICENSE_KEY'] = 'right'
+      manager = NewRelic::Agent::Configuration::Manager.new
+      manager.apply_config({:license_key => 'wrong'}, 1)
+
+      assert_equal 'right', manager['license_key']
+    end
+
+    def test_config_values_should_be_memoized
+      @manager.apply_config(:setting => 'correct value')
+      assert_equal 'correct value', @manager[:setting]
+
+      @manager.config_stack.unshift(:setting => 'wrong value')
+      assert_equal 'correct value', @manager[:setting]
+    end
+
+    def test_dotted_hash_to_hash_is_plain_hash
+      dotted = NewRelic::Agent::Configuration::DottedHash.new({})
+      assert_equal(::Hash, dotted.to_hash.class)
+    end
+
+    def test_to_collector_hash
+      @manager.instance_variable_set(:@config_stack, [])
+      @manager.apply_config(:eins => Proc.new { self[:one] })
+      @manager.apply_config(:one => 1)
+      @manager.apply_config(:two => 2)
+      @manager.apply_config(:nested => {:madness => 'test'})
+      @manager.apply_config(:'nested.madness' => 'test')
+
+      assert_equal({ :eins => 1, :one => 1, :two => 2, :'nested.madness' => 'test' },
+                   @manager.to_collector_hash)
+    end
+
+    # Necessary to keep the pruby marshaller happy
+    def test_to_collector_hash_returns_bare_hash
+      @manager.instance_variable_set(:@config_stack, [])
+      @manager.apply_config(:eins => Proc.new { self[:one] })
+
+      assert_equal(::Hash, @manager.to_collector_hash.class)
+    end
+
+    def test_config_masks
+      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { true }
+
+      @manager.apply_config(:boo => 1)
+
+      assert_equal false, @manager.to_collector_hash.has_key?(:boo)
+    end
+
+    def test_config_masks_conditionally
+      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { false }
+
+      @manager.apply_config(:boo => 1)
+
+      assert @manager.to_collector_hash.has_key?(:boo)
+    end
+
+    def test_config_masks_thread_profiler
+      supported = NewRelic::Agent::ThreadProfiler.is_supported?
+      reported_config = @manager.to_collector_hash
+
+      if supported
+        assert_not_nil reported_config[:'thread_profiler.enabled']
+      else
+        assert_equal nil, reported_config[:'thread_profiler.enabled']
+      end
+    end
+
+    def test_replacing_a_layer_by_class
+      old_config = NewRelic::Agent::Configuration::ManualSource.new(:test => 'wrong')
+      @manager.apply_config(old_config, 1)
+      new_config = NewRelic::Agent::Configuration::ManualSource.new(:test => 'right')
+      @manager.replace_or_add_config(new_config)
+
+      assert_equal 'right', @manager[:test]
+      assert_equal 3, @manager.config_stack.size
+      assert_equal 1, @manager.config_stack.map{|s| s.class} \
+        .index(NewRelic::Agent::Configuration::ManualSource)
+    end
+
+    def test_registering_a_callback
+      observed_value = 'old'
+      @manager.apply_config(:test => 'original')
+
+      @manager.register_callback(:test) do |value|
+        observed_value = value
+      end
+      assert_equal 'original', observed_value
+
+      @manager.apply_config(:test => 'new')
+      assert_equal 'new', observed_value
+    end
+
+    def test_callback_not_called_if_no_change
+      @manager.apply_config(:test => true, :other => false)
+      @manager.register_callback(:test) do |value|
+        state = 'wrong'
+      end
+      state = 'right'
+      config = {:test => true}
+      @manager.apply_config(config)
+      @manager.remove_config(config)
+
+      assert_equal 'right', state
+    end
+
+    def test_finished_configuring
+      @manager.apply_config(:layer => "yo")
+      assert_equal false, @manager.finished_configuring?
+
+      @manager.apply_config(ServerSource.new({}))
+      assert_equal true, @manager.finished_configuring?
+    end
+
+    def test_notifies_finished_configuring
+      called = false
+      NewRelic::Agent.instance.events.subscribe(:finished_configuring) { called = true }
+      @manager.apply_config(ServerSource.new({}))
+
+      assert_equal true, called
+    end
+
+    def test_doesnt_notify_unless_finished
+      called = false
+      NewRelic::Agent.instance.events.subscribe(:finished_configuring) { called = true }
+
+      @manager.apply_config(:fake => "config")
+      @manager.apply_config(ManualSource.new(:manual => true))
+      @manager.apply_config(YamlSource.new("", "test"))
+
+      assert_equal false, called
+    end
+
+
+    def test_should_log_when_applying
+      expects_logging(:debug, anything, includes("asdf"))
+      @manager.apply_config(:test => "asdf")
+    end
+
+    def test_should_log_when_removing
+      config = { :test => "asdf" }
+      @manager.apply_config(config)
+
+      expects_logging(:debug, anything, Not(includes("asdf")))
+      @manager.remove_config(config)
+    end
+
+    class TestSource < ::Hash
+      def test_config_accessor
+        'some value'
+      end
+    end
+  end
+end

data/test/new_relic/agent/configuration/server_source_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/server_source'
+
+module NewRelic::Agent::Configuration
+  class ServerSourceTest < Test::Unit::TestCase
+    def setup
+      config = {
+        'agent_config' => {
+          'slow_sql.enabled'                         => true,
+          'transaction_tracer.transaction_threshold' => 'apdex_f',
+          'transaction_tracer.record_sql'            => 'raw',
+          'error_collector.enabled'                  => true
+        },
+        'apdex_t'                => 1.0,
+        'collect_errors'         => false,
+        'collect_traces'         => true,
+        'web_transactions_apdex' => { 'Controller/some/txn' => 1.5 }
+      }
+      @source = ServerSource.new(config)
+    end
+
+    def test_should_set_apdex_t
+      assert_equal 1.0, @source[:apdex_t]
+    end
+
+    def test_should_set_agent_config_values
+      assert_equal 'raw', @source[:'transaction_tracer.record_sql']
+    end
+
+    def test_should_not_dot_the_agent_config_sub_hash
+      assert_nil @source[:'agent_config.slow_sql.enabled']
+    end
+
+    def test_should_enable_tracer_as_configured
+      assert @source[:'slow_sql.enabled']
+    end
+
+    def test_should_disable_tracer_as_configured
+      assert !@source[:'error_collector.enabled']
+    end
+
+    def test_should_ignore_apdex_f_setting_for_transaction_threshold
+      assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
+    end
+
+    def test_should_not_dot_the_web_transactions_apdex_hash
+      assert_equal 1.5, @source[:web_transactions_apdex]['Controller/some/txn']
+    end
+  end
+end