newrelic_rpm 3.6.4.122 → 3.6.5.130

data/test/new_relic/agent/new_relic_service_test.rb

@@ -112,32 +112,36 @@ class NewRelicServiceTest < Test::Unit::TestCase
   # testing that the CA file we ship actually validates our server's
   # certificate. It's used for customers who enable verify_certificate
   def test_cert_file
-    require 'socket'
-    require 'openssl'
-
-    s   = TCPSocket.new 'collector.newrelic.com', 443
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @service.cert_file_path
-    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    s   = OpenSSL::SSL::SSLSocket.new s, ctx
-    s.connect
+    if internet_connection?
+      require 'socket'
+      require 'openssl'
+
+      s   = TCPSocket.new 'collector.newrelic.com', 443
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.ca_file = @service.cert_file_path
+      ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      s   = OpenSSL::SSL::SSLSocket.new s, ctx
+      s.connect
     # should not raise an error
+    end
   end
 
   # see above, but for staging, as well. This allows us to test new
   # certificates in a non-customer-facing place before setting them
   # live.
   def test_staging_cert_file
-    require 'socket'
-    require 'openssl'
-
-    s   = TCPSocket.new 'staging-collector.newrelic.com', 443
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @service.cert_file_path
-    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    s   = OpenSSL::SSL::SSLSocket.new s, ctx
-    s.connect
-    # should not raise an error
+    if internet_connection?
+      require 'socket'
+      require 'openssl'
+
+      s   = TCPSocket.new 'staging-collector.newrelic.com', 443
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.ca_file = @service.cert_file_path
+      ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      s   = OpenSSL::SSL::SSLSocket.new s, ctx
+      s.connect
+      # should not raise an error
+    end
   end
 
   def test_initialize_uses_correct_license_key_settings

data/test/new_relic/agent/stats_engine/metric_stats_test.rb

@@ -143,18 +143,6 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     assert_equal(1, @engine.metrics.size)
   end
 
-  def test_record_metrics_accepts_explicit_scope
-    in_transaction('scopey') do
-      @engine.record_metrics('foo', 42, :scoped => true, :scope => 'not scopey')
-    end
-    unscoped_stats = @engine.get_stats('foo', false)
-    scoped_stats_scopey = @engine.get_stats('foo', true, true, 'scopey')
-    scoped_stats_not_scopey = @engine.get_stats('foo', true, true, 'not scopey')
-    assert_equal(1, unscoped_stats.call_count)
-    assert_equal(0, scoped_stats_scopey.call_count)
-    assert_equal(1, scoped_stats_not_scopey.call_count)
-  end
-
   def test_record_metrics_accepts_block
     @engine.record_metrics('foo') do |stats|
       stats.call_count = 999
@@ -183,6 +171,35 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     assert_equal(nthreads * iterations, stats_m2.call_count)
   end
 
+  def test_record_metrics_internal_writes_to_global_stats_hash_if_no_txn
+    specs = [
+      NewRelic::MetricSpec.new('foo'),
+      NewRelic::MetricSpec.new('foo', 'scope')
+    ]
+
+    2.times { @engine.record_metrics_internal(specs, 10, 5) }
+
+    expected = { :call_count => 2, :total_call_time => 20, :total_exclusive_time => 10 }
+    assert_metrics_recorded('foo' => expected, ['foo', 'scope'] => expected)
+  end
+
+  def test_record_metrics_internal_writes_to_transaction_stats_hash_if_txn
+    specs = [
+      NewRelic::MetricSpec.new('foo'),
+      NewRelic::MetricSpec.new('foo', 'scope')
+    ]
+
+    in_transaction do
+      2.times { @engine.record_metrics_internal(specs, 10, 5) }
+      # still in the txn, so metrics should not be visible in the global stats
+      # hash yet
+      assert_metrics_not_recorded(['foo', ['foo, scope']])
+    end
+
+    expected = { :call_count => 2, :total_call_time => 20, :total_exclusive_time => 10 }
+    assert_metrics_recorded('foo' => expected, ['foo', 'scope'] => expected)
+  end
+
   def test_transaction_stats_are_tracked_separately
     in_transaction do
       @engine.record_metrics('foo', 1)

data/test/new_relic/agent/stats_hash_test.rb

@@ -17,7 +17,7 @@ class NewRelic::Agent::StatsHashTest < Test::Unit::TestCase
   def test_record_accpets_single_metric_spec
     spec = NewRelic::MetricSpec.new('foo/bar')
     stats = @hash[spec]
-    stats.expects(:record_data_point).with(42)
+    stats.expects(:record_data_point).with(42, 42)
     @hash.record(spec, 42)
   end
 
@@ -26,8 +26,8 @@ class NewRelic::Agent::StatsHashTest < Test::Unit::TestCase
     spec2 = NewRelic::MetricSpec.new('foo/bar', 'scope2')
     stats1 = @hash[spec1]
     stats2 = @hash[spec2]
-    stats1.expects(:record_data_point).with(42)
-    stats2.expects(:record_data_point).with(42)
+    stats1.expects(:record_data_point).with(42, 42)
+    stats2.expects(:record_data_point).with(42, 42)
     @hash.record([spec1, spec2], 42)
   end
 
@@ -60,6 +60,27 @@ class NewRelic::Agent::StatsHashTest < Test::Unit::TestCase
     @hash.record(spec, other_stats)
   end
 
+  def test_record_accepts_exclusive_time_with_numeric
+    spec = NewRelic::MetricSpec.new('foo')
+    stats = @hash[spec]
+    stats.expects(:record_data_point).with(42, 10)
+    @hash.record(spec, 42, 10)
+  end
+
+  def test_record_accepts_apdex_t_with_symbol
+    spec = NewRelic::MetricSpec.new('foo')
+    apdex_t = 99
+    1.times { @hash.record(spec, :apdex_s, apdex_t) }
+    2.times { @hash.record(spec, :apdex_t, apdex_t) }
+    3.times { @hash.record(spec, :apdex_f, apdex_t) }
+    stats = @hash[spec]
+    assert_equal(1, stats.apdex_s)
+    assert_equal(2, stats.apdex_t)
+    assert_equal(3, stats.apdex_f)
+    assert_equal(99, stats.min_call_time)
+    assert_equal(99, stats.max_call_time)
+  end
+
   def test_merge_merges
     specs = [
       NewRelic::MetricSpec.new('foo'),

data/test/new_relic/agent/stats_test.rb

@@ -68,11 +68,11 @@ class NewRelic::Agent::StatsTest < Test::Unit::TestCase
   def test_apdex_recording
     s = NewRelic::Agent::Stats.new
 
-    s.record_apdex_s
-    s.record_apdex_t
+    s.record_apdex(:apdex_s, 1)
+    s.record_apdex(:apdex_t, 1)
 
-    s.record_apdex_f
-    s.record_apdex_t
+    s.record_apdex(:apdex_f, 1)
+    s.record_apdex(:apdex_t, 1)
 
     assert_equal(1, s.apdex_s)
     assert_equal(1, s.apdex_f)

data/test/new_relic/agent/transaction/pop_test.rb

@@ -67,7 +67,7 @@ class NewRelic::Agent::Transaction::PopTest < Test::Unit::TestCase
   end
 
   def test_record_jruby_cpu_burn
-    NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).expects(:record_data_point).with(1.0)
+    NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).expects(:record_data_point).with(1.0, 1.0)
     record_jruby_cpu_burn(1.0)
   end
 

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -954,6 +954,24 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     end
   end
 
+  def test_build_database_statement_uses_override_obfuscation_adapter_if_connection_config_is_nil
+    with_config(:override_sql_obfuscation_adapter => 'GumbyDB') do
+      config = nil
+      sql = "SELECT * FROM \"horses\" WHERE \"name\" = 'pokey'"
+      statement = @sampler.build_database_statement(sql, config, Proc.new {})
+      assert_equal 'GumbyDB', statement.adapter
+    end
+  end
+
+  def test_build_database_statement_uses_override_obfuscation_adapter_if_connection_config_adapter_is_mysql
+    with_config(:override_sql_obfuscation_adapter => 'GumbyDB') do
+      config = {:adapter => 'mysql'}
+      sql = "SELECT * FROM \"horses\" WHERE \"name\" = 'pokey'"
+      statement = @sampler.build_database_statement(sql, config, nil)
+      assert_equal 'GumbyDB', statement.adapter
+    end
+  end
+
   class Dummy
     include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
     def run(n)

data/test/new_relic/agent/transaction_test.rb

@@ -10,6 +10,8 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
 
   def setup
     @txn = NewRelic::Agent::Transaction.new
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+    @stats_engine.reset_stats
   end
 
   def test_request_parsing__none
@@ -63,47 +65,29 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
     assert_equal 500, txn.queue_time
   end
 
-  def test_update_apdex_records_failed_when_specified
-    stats = NewRelic::Agent::Stats.new
-    NewRelic::Agent::Transaction.update_apdex(stats, 0.1, true)
-    assert_equal 0, stats.apdex_s
-    assert_equal 0, stats.apdex_t
-    assert_equal 1, stats.apdex_f
+  def test_apdex_bucket_counts_errors_as_frustrating
+    bucket = NewRelic::Agent::Transaction.apdex_bucket(0.1, true, 2)
+    assert_equal(:apdex_f, bucket)
   end
 
-  def test_update_apdex_records_satisfying
-    stats = NewRelic::Agent::Stats.new
-    with_config(:apdex_t => 1) do
-      NewRelic::Agent::Transaction.update_apdex(stats, 0.5, false)
-    end
-    assert_equal 1, stats.apdex_s
-    assert_equal 0, stats.apdex_t
-    assert_equal 0, stats.apdex_f
+  def test_apdex_bucket_counts_values_under_apdex_t_as_satisfying
+    bucket = NewRelic::Agent::Transaction.apdex_bucket(0.5, false, 1)
+    assert_equal(:apdex_s, bucket)
   end
 
-  def test_update_apdex_records_tolerating
-    stats = NewRelic::Agent::Stats.new
-    with_config(:apdex_t => 1) do
-      NewRelic::Agent::Transaction.update_apdex(stats, 1.5, false)
-    end
-    assert_equal 0, stats.apdex_s
-    assert_equal 1, stats.apdex_t
-    assert_equal 0, stats.apdex_f
+  def test_apdex_bucket_counts_values_of_1_to_4x_apdex_t_as_tolerating
+    bucket = NewRelic::Agent::Transaction.apdex_bucket(1.01, false, 1)
+    assert_equal(:apdex_t, bucket)
+    bucket = NewRelic::Agent::Transaction.apdex_bucket(3.99, false, 1)
+    assert_equal(:apdex_t, bucket)
   end
 
-  def test_update_apdex_records_failing
-    stats = NewRelic::Agent::Stats.new
-    with_config(:apdex_t => 1) do
-      NewRelic::Agent::Transaction.update_apdex(stats, 4.5, false)
-    end
-    assert_equal 0, stats.apdex_s
-    assert_equal 0, stats.apdex_t
-    assert_equal 1, stats.apdex_f
+  def test_apdex_bucket_count_values_over_4x_apdex_t_as_frustrating
+    bucket = NewRelic::Agent::Transaction.apdex_bucket(4.01, false, 1)
+    assert_equal(:apdex_f, bucket)
   end
 
   def test_update_apdex_records_correct_apdex_for_key_transaction
-    txn_info = NewRelic::Agent::TransactionInfo.get
-    stats = NewRelic::Agent::Stats.new
     config = {
       :web_transactions_apdex => {
         'Controller/slow/txn' => 4,
@@ -112,50 +96,61 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
       :apdex => 1
     }
 
-    txn_info.transaction.name = 'Controller/slow/txn'
-    with_config(config, :do_not_cast => true) do
-      NewRelic::Agent::Transaction.update_apdex(stats, 3.5, false)
-      NewRelic::Agent::Transaction.update_apdex(stats, 5.5, false)
-      NewRelic::Agent::Transaction.update_apdex(stats, 16.5, false)
-    end
-    assert_equal 1, stats.apdex_s
-    assert_equal 1, stats.apdex_t
-    assert_equal 1, stats.apdex_f
-
-    txn_info.transaction.name = 'Controller/fast/txn'
-    with_config(config, :do_not_cast => true) do
-      NewRelic::Agent::Transaction.update_apdex(stats, 0.05, false)
-      NewRelic::Agent::Transaction.update_apdex(stats, 0.2, false)
-      NewRelic::Agent::Transaction.update_apdex(stats, 0.5, false)
-    end
-    assert_equal 2, stats.apdex_s
-    assert_equal 2, stats.apdex_t
-    assert_equal 2, stats.apdex_f
+    freeze_time
+    t0 = Time.now
 
-    txn_info.transaction.name = 'Controller/other/txn'
+    # Setting the transaction name from within the in_transaction block seems
+    # like cheating, but it mimics the way things are actually done, where we
+    # finalize the transaction name before recording the Apdex metrics.
     with_config(config, :do_not_cast => true) do
-      NewRelic::Agent::Transaction.update_apdex(stats, 0.5, false)
-      NewRelic::Agent::Transaction.update_apdex(stats, 2, false)
-      NewRelic::Agent::Transaction.update_apdex(stats, 5, false)
+      in_web_transaction('Controller/slow/txn') do
+        NewRelic::Agent::Transaction.current.name = 'Controller/slow/txn'
+        NewRelic::Agent::Transaction.record_apdex(t0 + 3.5,  false)
+        NewRelic::Agent::Transaction.record_apdex(t0 + 5.5,  false)
+        NewRelic::Agent::Transaction.record_apdex(t0 + 16.5, false)
+      end
+      assert_metrics_recorded(
+        'Apdex'          => { :apdex_s => 1, :apdex_t => 1, :apdex_f => 1 },
+        'Apdex/slow/txn' => { :apdex_s => 1, :apdex_t => 1, :apdex_f => 1 }
+      )
+
+      in_web_transaction('Controller/fast/txn') do
+        NewRelic::Agent::Transaction.current.name = 'Controller/fast/txn'
+        NewRelic::Agent::Transaction.record_apdex(t0 + 0.05, false)
+        NewRelic::Agent::Transaction.record_apdex(t0 + 0.2,  false)
+        NewRelic::Agent::Transaction.record_apdex(t0 + 0.5,  false)
+      end
+      assert_metrics_recorded(
+        'Apdex'          => { :apdex_s => 2, :apdex_t => 2, :apdex_f => 2 },
+        'Apdex/fast/txn' => { :apdex_s => 1, :apdex_t => 1, :apdex_f => 1 }
+      )
+
+      in_web_transaction('Controller/other/txn') do
+        NewRelic::Agent::Transaction.current.name = 'Controller/other/txn'
+        NewRelic::Agent::Transaction.record_apdex(t0 + 0.5, false)
+        NewRelic::Agent::Transaction.record_apdex(t0 + 2,   false)
+        NewRelic::Agent::Transaction.record_apdex(t0 + 5,   false)
+      end
+      assert_metrics_recorded(
+        'Apdex'           => { :apdex_s => 3, :apdex_t => 3, :apdex_f => 3 },
+        'Apdex/other/txn' => { :apdex_s => 1, :apdex_t => 1, :apdex_f => 1 }
+      )
     end
-    assert_equal 3, stats.apdex_s
-    assert_equal 3, stats.apdex_t
-    assert_equal 3, stats.apdex_f
   end
 
   def test_record_apdex_stores_apdex_t_in_min_and_max
-    stats_engine = NewRelic::Agent.instance.stats_engine
-    stats_engine.reset_stats
-    metric = stub(:apdex_metric_path => 'Apdex/Controller/some/txn')
-    NewRelic::Agent.instance.instance_variable_set(:@stats_engine, stats_engine)
-
     with_config(:apdex_t => 2.5) do
-      NewRelic::Agent::Transaction.record_apdex(metric, 1, 1, false)
+      in_web_transaction('Controller/some/txn') do
+        NewRelic::Agent::Transaction.current.name = 'Controller/some/txn'
+        NewRelic::Agent::Transaction.record_apdex(Time.now, false)
+      end
     end
-    assert_equal 2.5, stats_engine.lookup_stats('Apdex').min_call_time
-    assert_equal 2.5, stats_engine.lookup_stats('Apdex').max_call_time
-    assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').min_call_time
-    assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').max_call_time
+
+    expected = { :min_call_time => 2.5, :max_call_time => 2.5 }
+    assert_metrics_recorded(
+      'Apdex' => expected,
+      'Apdex/some/txn' => expected
+    )
   end
 
   def test_start_adds_controller_context_to_txn_stack
@@ -213,7 +208,7 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
     NewRelic::Agent.record_metric("HttpDispatcher", 2.1)
     NewRelic::Agent::Transaction.stop('txn')
 
-    assert_equal 2.1, options[:web_duration]
+    assert_equal 2.1, options[:webDuration]
   end
 
   def test_parent_returns_parent_transaction_if_there_is_one

data/test/new_relic/agent_test.rb

@@ -254,6 +254,26 @@ module NewRelic
       NewRelic::Agent.record_metric('foo', stats_hash)
     end
 
+    def test_record_metric_sets_default_hash_values_for_missing_keys
+      dummy_engine = NewRelic::Agent.agent.stats_engine
+      incomplete_stats_hash = {
+        :count => 12,
+        :max   => 5,
+        :sum_of_squares => 999
+      }
+
+      expected_stats = NewRelic::Agent::Stats.new()
+      expected_stats.call_count = 12
+      expected_stats.total_call_time = 0.0
+      expected_stats.total_exclusive_time = 0.0
+      expected_stats.min_call_time = 0.0
+      expected_stats.max_call_time = 5
+      expected_stats.sum_of_squares = 999
+
+      dummy_engine.expects(:record_metrics).with('foo', expected_stats)
+      NewRelic::Agent.record_metric('foo', incomplete_stats_hash)
+    end
+
     def test_increment_metric
       dummy_engine = NewRelic::Agent.agent.stats_engine
       dummy_stats = mock

data/test/new_relic/dependency_detection_test.rb

@@ -0,0 +1,99 @@
+# 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 DependencyDetectionTest < Test::Unit::TestCase
+
+  def setup
+    @original_items = DependencyDetection.items
+    DependencyDetection.items = []
+  end
+
+  def teardown
+    DependencyDetection.items = @original_items
+  end
+
+  def test_passes_dependency
+    executed = false
+
+    DependencyDetection.defer do
+      depends_on { true }
+      executes   { executed = true }
+    end
+    DependencyDetection.detect!
+
+    assert executed
+  end
+
+  def test_fails_dependency
+    executed = false
+
+    DependencyDetection.defer do
+      depends_on { true }
+      depends_on { false }
+      executes   { executed = true }
+    end
+    DependencyDetection.detect!
+
+    assert !executed
+  end
+
+  def test_short_circuits_on_failure
+    executed = false
+
+    # Requires that depends_on would let failures pass through, which it does
+    DependencyDetection.defer do
+      depends_on { false }
+      depends_on { raise "OH NOES"}
+      executes   { executed = true }
+    end
+    DependencyDetection.detect!
+
+    assert !executed
+  end
+
+  def test_named_disabling_defaults_to_allowed
+    executed = false
+
+    DependencyDetection.defer do
+      named :testing
+      executes { executed = true }
+    end
+    DependencyDetection.detect!
+
+    assert executed
+  end
+
+  def test_named_disabling_allows_with_explicit_value
+    executed = false
+
+    DependencyDetection.defer do
+      named :testing
+      executes { executed = true }
+    end
+
+    with_config(:disable_testing => false) do
+      DependencyDetection.detect!
+    end
+
+    assert executed
+  end
+
+  def test_named_disabling
+    executed = false
+
+    DependencyDetection.defer do
+      named :testing
+      executes { executed = true }
+    end
+
+    with_config(:disable_testing => true) do
+      DependencyDetection.detect!
+    end
+
+    assert !executed
+  end
+
+end