newrelic_rpm 3.6.2.96 → 3.6.3.103.beta

data/lib/new_relic/agent.rb

@@ -334,6 +334,23 @@ module NewRelic
       end
     end
 
+
+    # Subscribe to events of +event_type+, calling the given +handler+
+    # when one is sent.
+    def subscribe(event_type, &handler)
+      agent.events.subscribe( event_type, &handler )
+    end
+
+
+    # Fire an event of the specified +event_type+, passing it an the given +args+
+    # to any registered handlers.
+    def notify(event_type, *args)
+      agent.events.notify( event_type, *args )
+    rescue => err
+      NewRelic::Agent.logger.debug "Ignoring exception during %p event notification" % [event_type]
+    end
+
+
     # This method disables the recording of transaction traces in the given
     # block.  See also #disable_all_tracing
     def disable_transaction_tracing

data/lib/new_relic/build.rb

@@ -1,2 +1,2 @@
-# GITSHA: dd7fc845a58dcc9cfb7f1be3f11d1dababa1c72b
-module NewRelic; module VERSION; BUILD='96'; end; end
+# GITSHA: 0b3609118317f2a210341a12bcf8759e9978fd28
+module NewRelic; module VERSION; BUILD='103.beta'; end; end

data/lib/new_relic/coerce.rb

@@ -18,7 +18,9 @@ module NewRelic
     end
 
     def float(value, context=nil)
-      Float(value)
+      result = Float(value)
+      raise "Value #{result.inspect} is not finite." unless result.finite?
+      result
     rescue => error
       log_failure(value, Float, context, error)
       0.0

data/lib/new_relic/rack/agent_hooks.rb

@@ -10,15 +10,29 @@ module NewRelic::Rack
       @app = app
     end
 
+    FIRED_FORMATS = {
+      :before_call => "newrelic.agent_hooks_before_fired",
+      :after_call  => "newrelic.agent_hooks_after_fired"
+    }
+
     # method required by Rack interface
     # [status, headers, response]
     def call(env)
-      events = NewRelic::Agent.instance.events
-      events.notify(:before_call, env)
+      notify(:before_call, env)
       result = @app.call(env)
-      events.notify(:after_call, env, result)
+      notify(:after_call, env, result)
       result
     end
+
+    def notify(event, env, *args)
+      key = FIRED_FORMATS[event]
+      events.notify(event, *([env] + args)) unless env[key]
+      env[key] = true
+    end
+
+    def events
+      NewRelic::Agent.instance.events
+    end
   end
 end
 

data/lib/new_relic/rack/browser_monitoring.rb

@@ -15,9 +15,10 @@ module NewRelic::Rack
     def call(env)
       result = @app.call(env)   # [status, headers, response]
 
-      if (NewRelic::Agent.browser_timing_header != "") && should_instrument?(result[0], result[1])
+      if (NewRelic::Agent.browser_timing_header != "") && should_instrument?(env, result[0], result[1])
         response_string = autoinstrument_source(result[2], result[1])
 
+        env[ALREADY_INSTRUMENTED_KEY] = true
         if response_string
           response = Rack::Response.new(response_string, result[0], result[1])
           response.finish
@@ -29,8 +30,12 @@ module NewRelic::Rack
       end
     end
 
-    def should_instrument?(status, headers)
-      status == 200 && headers["Content-Type"] && headers["Content-Type"].include?("text/html") &&
+    ALREADY_INSTRUMENTED_KEY = "newrelic.browser_monitoring_already_instrumented"
+
+    def should_instrument?(env, status, headers)
+      status == 200 &&
+        !env[ALREADY_INSTRUMENTED_KEY] &&
+        headers["Content-Type"] && headers["Content-Type"].include?("text/html") &&
         !headers['Content-Disposition'].to_s.include?('attachment')
     end
 

data/lib/new_relic/rack/error_collector.rb

@@ -37,6 +37,8 @@ module NewRelic::Rack
     end
 
     def ignored_in_controller?(exception, request)
+      return true if request.env['newrelic.ignored']
+
       if request.env['action_dispatch.request.parameters']
         ignore_actions = newrelic_ignore_for_controller(request.env['action_dispatch.request.parameters']['controller'])
         action_name = request.env['action_dispatch.request.parameters']['action']

data/lib/new_relic/transaction_sample/segment.rb

@@ -110,29 +110,6 @@ module NewRelic
         count
       end
 
-      # Walk through the tree and truncate the segments in a
-      # depth-first manner
-      def truncate(max)
-        return 1 unless @called_segments
-        total, self.called_segments = truncate_each_child(max - 1)
-        total+1
-      end
-
-      def truncate_each_child(max)
-        total = 0
-        accumulator = []
-        called_segments.each { | s |
-          if total == max
-            true
-          else
-            total += s.truncate(max - total)
-            accumulator << s
-          end
-        }
-        total
-        [total, accumulator]
-      end
-
       def []=(key, value)
         # only create a parameters field if a parameter is set; this will save
         # bandwidth etc as most segments have no parameters

data/lib/new_relic/transaction_sample.rb

@@ -38,15 +38,6 @@ module NewRelic
       @segment_count
     end
 
-    # Truncates the transaction sample to a maximum length determined
-    # by the passed-in parameter. Operates recursively on the entire
-    # tree of transaction segments in a depth-first manner
-    def truncate(max)
-      return if @segment_count < max
-      @root_segment.truncate(max + 1)
-      @segment_count = max
-    end
-
     # makes sure that the parameter cache for segment count is set to
     # the correct value
     def ensure_segment_count_set(count)

data/lib/new_relic/version.rb

@@ -12,7 +12,7 @@ module NewRelic
 
     MAJOR = 3
     MINOR = 6
-    TINY  = 2
+    TINY  = 3
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/test/agent_helper.rb

@@ -0,0 +1,204 @@
+# 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.
+
+# These helpers should not have any gem dependencies except on newrelic_rpm
+# itself, and should be usable from within any multiverse suite.
+
+def assert_between(floor, ceiling, value, message="expected #{floor} <= #{value} <= #{ceiling}")
+  assert((floor <= value && value <= ceiling), message)
+end
+
+def assert_in_delta(expected, actual, delta)
+  assert_between((expected - delta), (expected + delta), actual)
+end
+
+def check_metric_time(metric, value, delta)
+  time = NewRelic::Agent.get_stats(metric).total_call_time
+  assert_in_delta(value, time, delta)
+end
+
+def check_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def check_unscoped_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats_unscoped(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def generate_unscoped_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats_no_scope(metric).call_count
+    sum
+  end
+end
+
+def generate_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats(metric).call_count
+    sum
+  end
+end
+
+def assert_does_not_call_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_equal first_metrics, last_metrics, "should not have changed these metrics"
+end
+
+def assert_calls_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+def assert_calls_unscoped_metrics(*metrics)
+  first_metrics = generate_unscoped_metric_counts(*metrics)
+  yield
+  last_metrics = generate_unscoped_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+unless defined?( assert_includes )
+  def assert_includes( collection, member, msg=nil )
+    msg = build_message( msg, "Expected ? to include ?", collection, member )
+    assert_block( msg ) { collection.include?(member) }
+  end
+end
+
+unless defined?( assert_not_includes )
+  def assert_not_includes( collection, member, msg=nil )
+    msg = build_message( msg, "Expected ? not to include ?", collection, member )
+    assert_block( msg ) { !collection.include?(member) }
+  end
+end
+
+def compare_metrics(expected, actual)
+  actual.delete_if {|a| a.include?('GC/cumulative') } # in case we are in REE
+  assert_equal(expected.to_a.sort, actual.to_a.sort, "extra: #{(actual - expected).to_a.inspect}; missing: #{(expected - actual).to_a.inspect}")
+end
+
+def metric_spec_from_specish(specish)
+  spec = case specish
+  when String then NewRelic::MetricSpec.new(specish)
+  when Array  then NewRelic::MetricSpec.new(*specish)
+  end
+  spec
+end
+
+def _normalize_metric_expectations(expectations)
+  case expectations
+  when Array
+    hash = {}
+    # Just assert that the metric is present, nothing about the attributes
+    expectations.each { |k| hash[k] = { } }
+    hash
+  else
+    expectations
+  end
+end
+
+def assert_metrics_recorded(expected)
+  expected = _normalize_metric_expectations(expected)
+  expected.each do |specish, expected_attrs|
+    expected_spec = metric_spec_from_specish(specish)
+    actual_stats = NewRelic::Agent.instance.stats_engine.lookup_stats(*Array(specish))
+    if !actual_stats
+      all_specs = NewRelic::Agent.instance.stats_engine.metric_specs
+      matches = all_specs.select { |spec| spec.name == expected_spec.name }
+      matches.map! { |m| "  #{m.inspect}" }
+      msg = "Did not find stats for spec #{expected_spec.inspect}."
+      msg += "\nDid find specs: [\n#{matches.join(",\n")}\n]" unless matches.empty?
+      msg += "\nAll specs in there were: [\n#{all_specs.map {|s| s.name}.join(",\n")}\n]"
+      assert(actual_stats, msg)
+    end
+    expected_attrs.each do |attr, expected_value|
+      actual_value = actual_stats.send(attr)
+      if attr == :call_count
+        assert_equal(expected_value, actual_value,
+          "Expected #{attr} for #{expected_spec} to be #{expected_value}, got #{actual_value}")
+      else
+        assert_in_delta(expected_value, actual_value, 0.0001,
+          "Expected #{attr} for #{expected_spec} to be ~#{expected_value}, got #{actual_value}")
+      end
+    end
+  end
+end
+
+def assert_metrics_recorded_exclusive(expected, options={})
+  expected = _normalize_metric_expectations(expected)
+  assert_metrics_recorded(expected)
+  recorded_metrics = NewRelic::Agent.instance.stats_engine.metrics
+  if options[:filter]
+    recorded_metrics = recorded_metrics.select { |m| m.match(options[:filter]) }
+  end
+  expected_metrics = expected.keys.map { |s| metric_spec_from_specish(s).to_s }
+  unexpected_metrics = recorded_metrics.select{|m| m !~ /GC\/cumulative/}
+  unexpected_metrics -= expected_metrics
+  assert_equal(0, unexpected_metrics.size, "Found unexpected metrics: [#{unexpected_metrics.join(', ')}]")
+end
+
+def assert_metrics_not_recorded(not_expected)
+  not_expected = _normalize_metric_expectations(not_expected)
+  found_but_not_expected = []
+  not_expected.each do |specish, _|
+    spec = metric_spec_from_specish(specish)
+    if NewRelic::Agent.instance.stats_engine.lookup_stats(*Array(specish))
+      found_but_not_expected << spec
+    end
+  end
+  assert_equal([], found_but_not_expected, "Found unexpected metrics: [#{found_but_not_expected.join(', ')}]")
+end
+
+# Mock up a transaction for testing purposes, optionally specifying a name and
+# transaction type. The given block will be executed within the context of the
+# dummy transaction.
+#
+# Examples:
+#
+# With default name ('dummy') and type (:other):
+#   in_transaction { ... }
+#
+# With an explicit transaction name and default type:
+#   in_transaction('foobar') { ... }
+#
+# With default name and explicit type:
+#   in_transaction(:type => :controller) { ... }
+#
+# With a transaction name plus type:
+#   in_transaction('foobar', :type => :controller) { ... }
+#
+def in_transaction(*args)
+  opts = (args.last && args.last.is_a?(Hash)) ? args.pop : {}
+  name = args.first || 'dummy'
+  defaults = { :type => :other }
+  options = defaults.merge(opts)
+  NewRelic::Agent.instance.instance_variable_set(:@transaction_sampler,
+                        NewRelic::Agent::TransactionSampler.new)
+  NewRelic::Agent.instance.stats_engine.transaction_sampler = \
+    NewRelic::Agent.instance.transaction_sampler
+  NewRelic::Agent::Transaction.start(options[:type])
+  val = yield
+  NewRelic::Agent::Transaction.stop(name)
+  val
+end
+
+# Convenience wrapper around in_transaction that sets the type so that it
+# looks like we are in a web transaction
+def in_web_transaction(name='dummy')
+  in_transaction(name, :type => :controller) do
+    yield
+  end
+end
+
+def freeze_time(now=Time.now)
+  Time.stubs(:now).returns(now)
+end
+
+def advance_time(seconds)
+  freeze_time(Time.now + seconds)
+end

data/test/config/newrelic.yml

@@ -24,7 +24,6 @@ test:
     - a
     - b
     - c
-  log_file_path: <%= ::Rails::VERSION::MAJOR >= 3 ? Rails.root : RAILS_ROOT %>/log
 
   # Some fixtures for newrelic.yml parsing tests
   erb_value: <%= 'hey'*3 %>

data/test/config/test_control.rb

@@ -22,7 +22,7 @@ class NewRelic::Control::Frameworks::Test < parent_class
   end
 
   def app
-    if defined?(::Rails::VERSION)
+    if defined?(::Rails) && defined?(::Rails::VERSION)
       if ::Rails::VERSION::MAJOR.to_i == 4
         :rails4
       elsif ::Rails::VERSION::MAJOR.to_i == 3
@@ -30,6 +30,8 @@ class NewRelic::Control::Frameworks::Test < parent_class
       else
         :rails
       end
+    else
+      :test
     end
   end
 

data/test/multiverse/suites/agent_only/key_transactions_test.rb

@@ -30,6 +30,10 @@ class KeyTransactionsTest < Test::Unit::TestCase
 
     NewRelic::Agent.manual_start(:sync_startup => true,
                                  :force_reconnect => true)
+
+    # Important that this be stubbed before any of our add_transaction_tracer's
+    # end up getting run in the test methods
+    @now = stub_time_now
   end
 
   def teardown
@@ -42,7 +46,7 @@ class KeyTransactionsTest < Test::Unit::TestCase
   FAILING    = 2
 
   def test_applied_correct_apdex_t_to_key_txn
-    TestWidget.new.key_txn(stub_time_now)
+    TestWidget.new.key_txn(@now)
     NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
 
     stats = $collector.reported_stats_for_metric('Apdex')[0]
@@ -51,7 +55,7 @@ class KeyTransactionsTest < Test::Unit::TestCase
   end
 
   def test_applied_correct_apdex_t_to_regular_txn
-    TestWidget.new.other_txn(stub_time_now)
+    TestWidget.new.other_txn(@now)
     NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
 
     stats = $collector.reported_stats_for_metric('Apdex')[0]
@@ -60,9 +64,8 @@ class KeyTransactionsTest < Test::Unit::TestCase
   end
 
   def test_applied_correct_tt_theshold
-    now = stub_time_now
-    TestWidget.new.key_txn(now)
-    TestWidget.new.other_txn(now)
+    TestWidget.new.key_txn(@now)
+    TestWidget.new.other_txn(@now)
 
     NewRelic::Agent.instance.send(:harvest_and_send_slowest_sample)
 

data/test/multiverse/suites/agent_only/logging_test.rb

@@ -22,7 +22,7 @@ class LoggingTest < Test::Unit::TestCase
   def test_logs_error_with_bad_app_name
     running_agent_writes_to_log( 
        {:app_name => false},
-        "Unable to determine application name.")
+        "No application name configured.")
   end
 
   def test_logs_dispatcher