newrelic_rpm 3.13.2.302 → 3.14.0.305

data/lib/new_relic/agent/transaction_event_aggregator.rb

@@ -7,6 +7,7 @@ require 'monitor'
 
 require 'newrelic_rpm' unless defined?( NewRelic )
 require 'new_relic/agent' unless defined?( NewRelic::Agent )
+require 'new_relic/agent/payload_metric_mapping'
 
 class NewRelic::Agent::TransactionEventAggregator
   include NewRelic::Coerce,
@@ -20,6 +21,7 @@ class NewRelic::Agent::TransactionEventAggregator
   TIMESTAMP_KEY                  = 'timestamp'.freeze
   NAME_KEY                       = 'name'.freeze
   DURATION_KEY                   = 'duration'.freeze
+  ERROR_KEY                      = 'error'.freeze
   GUID_KEY                       = 'nr.guid'.freeze
   REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
   CAT_TRIP_ID_KEY                = 'nr.tripId'.freeze
@@ -170,54 +172,15 @@ class NewRelic::Agent::TransactionEventAggregator
     end
   end
 
-  def self.map_metric(metric_name, to_add={})
-    to_add.values.each(&:freeze)
-
-    mappings = OVERVIEW_SPECS.fetch(metric_name, {})
-    mappings.merge!(to_add)
-
-    OVERVIEW_SPECS[metric_name] = mappings
-  end
-
-  OVERVIEW_SPECS = {}
-
-  # All Transactions
-  # Don't need to use the transaction-type specific metrics since this is
-  # scoped to just one transaction, so Datastore/all has what we want.
-  map_metric('Datastore/all',         :total_call_time => "databaseDuration")
-  map_metric('Datastore/all',         :call_count      => "databaseCallCount")
-  map_metric('GC/Transaction/all',    :total_call_time => "gcCumulative")
-
-  # Web Metrics
-  map_metric('WebFrontend/QueueTime', :total_call_time => "queueDuration")
-  map_metric('External/allWeb',       :total_call_time => "externalDuration")
-  map_metric('External/allWeb',       :call_count      => "externalCallCount")
-
-  # Background Metrics
-  map_metric('External/allOther',     :total_call_time => "externalDuration")
-  map_metric('External/allOther',     :call_count      => "externalCallCount")
-
-  def append_metrics(txn_metrics, sample)
-    if txn_metrics
-      OVERVIEW_SPECS.each do |(name, extracted_values)|
-        if txn_metrics.has_key?(name)
-          stat = txn_metrics[name]
-          extracted_values.each do |value_name, key_name|
-            sample[key_name] = stat.send(value_name)
-          end
-        end
-      end
-    end
-  end
-
   def create_main_event(payload)
     sample = {
       TIMESTAMP_KEY => float(payload[:start_timestamp]),
       NAME_KEY      => string(payload[:name]),
       DURATION_KEY  => float(payload[:duration]),
       TYPE_KEY      => SAMPLE_TYPE,
+      ERROR_KEY     => payload[:error]
     }
-    append_metrics(payload[:metrics], sample)
+    NewRelic::Agent::PayloadMetricMapping.append_mapped_metrics(payload[:metrics], sample)
     optionally_append(GUID_KEY,                       :guid, sample, payload)
     optionally_append(REFERRING_TRANSACTION_GUID_KEY, :referring_transaction_guid, sample, payload)
     optionally_append(CAT_TRIP_ID_KEY,                :cat_trip_id, sample, payload)

data/lib/new_relic/noticed_error.rb

@@ -10,8 +10,8 @@ class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
 
   attr_accessor :path, :timestamp, :message, :exception_class_name,
-                :request_uri, :file_name, :line_number, :stack_trace,
-                :attributes_from_notice_error, :attributes
+                :request_uri, :request_port, :file_name, :line_number,
+                :stack_trace, :attributes_from_notice_error, :attributes
 
   attr_reader   :exception_id, :is_internal
 
@@ -86,7 +86,7 @@ class NewRelic::NoticedError
       string(path),
       string(message),
       string(exception_class_name),
-      build_params ]
+      processed_attributes ]
   end
 
   USER_ATTRIBUTES = "userAttributes".freeze
@@ -97,12 +97,17 @@ class NewRelic::NoticedError
 
   DESTINATION = NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
 
-  def build_params
-    params = base_parameters
-    append_attributes(params, USER_ATTRIBUTES, merged_custom_attributes)
-    append_attributes(params, AGENT_ATTRIBUTES, build_agent_attributes)
-    append_attributes(params, INTRINSIC_ATTRIBUTES, build_intrinsic_attributes)
-    params
+  # Note that we process attributes lazily and store the result. This is because
+  # there is a possibility that a noticed error will be discarded and not sent back
+  # as a traced error or TransactionError.
+  def processed_attributes
+    @processed_attributes ||= begin
+      attributes = base_parameters
+      append_attributes(attributes, USER_ATTRIBUTES, merged_custom_attributes)
+      append_attributes(attributes, AGENT_ATTRIBUTES, build_agent_attributes)
+      append_attributes(attributes, INTRINSIC_ATTRIBUTES, build_intrinsic_attributes)
+      attributes
+    end
   end
 
   def base_parameters
@@ -161,4 +166,15 @@ class NewRelic::NoticedError
     outgoing_params[outgoing_key] = source_attributes || {}
   end
 
+  def agent_attributes
+    processed_attributes[AGENT_ATTRIBUTES]
+  end
+
+  def custom_attributes
+    processed_attributes[USER_ATTRIBUTES]
+  end
+
+  def intrinsic_attributes
+    processed_attributes[INTRINSIC_ATTRIBUTES]
+  end
 end

data/lib/new_relic/rack/agent_middleware.rb

@@ -35,6 +35,11 @@ module NewRelic
         return if NewRelic::Agent.config[:disable_middleware_instrumentation]
         super
       end
+
+      def capture_response_content_type(state, result)
+        return if NewRelic::Agent.config[:disable_middleware_instrumentation]
+        super
+      end
     end
   end
 end

data/lib/new_relic/version.rb

@@ -11,8 +11,8 @@ module NewRelic
     end
 
     MAJOR = 3
-    MINOR = 13
-    TINY  = 2
+    MINOR = 14
+    TINY  = 0
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/newrelic_rpm.gemspec

@@ -56,6 +56,12 @@ EOS
     s.add_development_dependency 'rb-fsevent'
   end
 
+  # rack-cache ~> 1.2 is specified by actionpack 3.2, but rack-cache 1.3.1 only works on Ruby 1.9.3 & newer. :(
+  # https://github.com/rtomayko/rack-cache/issues/124
+  if RUBY_VERSION < "1.9.3"
+   s.add_development_dependency "rack-cache", "~> 1.2.0"
+  end
+
   # version lock down for i18n that is compatible with Ruby 1.8.7
   s.add_development_dependency 'i18n', '0.6.11'
 

data/test/agent_helper.rb

@@ -26,12 +26,25 @@ def assert_in_delta(expected, actual, delta)
   assert_between((expected - delta), (expected + delta), actual)
 end
 
-def assert_has_error(error_class)
+def harvest_error_traces!
+  NewRelic::Agent.instance.error_collector.error_trace_aggregator.harvest!
+end
+
+def reset_error_traces!
+  NewRelic::Agent.instance.error_collector.error_trace_aggregator.reset!
+end
+
+def assert_has_traced_error(error_class)
+  errors = harvest_error_traces!
   assert \
-    NewRelic::Agent.instance.error_collector.errors.find {|e| e.exception_class_name == error_class.name} != nil, \
+    errors.find {|e| e.exception_class_name == error_class.name} != nil, \
     "Didn't find error of class #{error_class}"
 end
 
+def last_traced_error
+  harvest_error_traces!.last
+end
+
 unless defined?( assert_block )
   def assert_block(*msgs)
     assert yield, *msgs
@@ -81,7 +94,7 @@ end
 # orderings of the key/value pairs in Hashes that were embedded in the request
 # body). So, this method traverses an object graph and only makes assertions
 # about the terminal (non-Array-or-Hash) nodes therein.
-def assert_audit_log_contains_object(audit_log_contents, o, format)
+def assert_audit_log_contains_object(audit_log_contents, o, format = :json)
   case o
   when Hash
     o.each do |k,v|
@@ -321,10 +334,6 @@ def refute_contains_request_params(attributes)
   end
 end
 
-def last_traced_error
-  NewRelic::Agent.agent.error_collector.errors.last
-end
-
 def last_transaction_trace
   NewRelic::Agent.agent.transaction_sampler.last_sample
 end

data/test/environments/norails/Gemfile

@@ -6,6 +6,7 @@ gem 'minitest', '~>4.7.5'
 gem 'mocha', :require => false
 gem 'rack'
 gem 'rack-test'
+gem 'json' if RUBY_VERSION == "1.8.7"
 
 platforms :rbx do
   gem "rubysl"

data/test/multiverse/lib/multiverse/runner.rb

@@ -83,7 +83,7 @@ module Multiverse
 
     GROUPS = {
       "agent"         => ["agent_only", "bare", "config_file_loading",
-                          "deferred_instrumentation", "high_security"],
+                          "deferred_instrumentation", "high_security", "no_json"],
       "api"           => ["grape"],
       "background"    => ["delayed_job", "rake", "resque", "sidekiq"],
       "database"      => ["datamapper", "mongo", "redis", "sequel"],

data/test/multiverse/lib/multiverse/suite.rb

@@ -174,18 +174,21 @@ module Multiverse
         f.puts newrelic_gemfile_line unless gemfile_text =~ /^\s*gem .newrelic_rpm./
         f.puts jruby_openssl_line unless gemfile_text =~ /^\s*gem .jruby-openssl./ || (defined?(JRUBY_VERSION) && JRUBY_VERSION > '1.7')
         f.puts minitest_line unless gemfile_text =~ /^\s*gem .minitest[^_]./
+        if RUBY_VERSION == "1.8.7"
+          f.puts "gem 'json'" unless gemfile_text =~ /^\s.*gem .json./
+        end
 
         rbx_gemfile_lines(f, gemfile_text)
 
         f.puts "  gem 'mocha', '0.14.0', :require => false"
 
         if debug
-          pry_version = RUBY_VERSION >= '1.8.7' ? '0.10.0' : '0.9.12'
+          pry_version = RUBY_VERSION > '1.8.7' ? '0.10.0' : '0.9.12'
 
           # Pry 0.10.0 breaks compatibility with Ruby 1.8.7 :(
           f.puts "  gem 'pry', '~> #{pry_version}'"
-          f.puts "  gem 'pry-byebug'" if RUBY_VERSION >= "2.0.0" && RUBY_ENGINE == "ruby"
-          f.puts "  gem 'pry-stack_explorer'" if RUBY_ENGINE == "ruby"
+          f.puts "  gem 'pry-byebug'" if defined?(RUBY_ENGINE) && RUBY_VERSION >= "2.0.0" && RUBY_ENGINE == "ruby"
+          f.puts "  gem 'pry-stack_explorer'" if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
         end
       end
       puts yellow("Gemfile.#{env_index} set to:") if verbose?

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

@@ -20,6 +20,18 @@ class AgentAttributesTest < Minitest::Test
     refute_browser_monitoring_has_agent_attribute("httpResponseCode")
   end
 
+  def test_response_content_type_default_destinations
+    run_transaction do |txn|
+      txn.response_content_type = 'application/json'
+    end
+
+    assert_transaction_trace_has_agent_attribute("response.headers.contentType", "application/json")
+    assert_event_has_agent_attribute("response.headers.contentType", "application/json")
+    assert_error_has_agent_attribute("response.headers.contentType", "application/json")
+
+    refute_browser_monitoring_has_agent_attribute("response.headers.contentType")
+  end
+
   def test_request_headers_referer_default_destinations
     txn_options = {:request => stub(:referer => "referrer", :path => "/")}
     run_transaction({}, txn_options) do |txn|
@@ -55,6 +67,51 @@ class AgentAttributesTest < Minitest::Test
     refute_browser_monitoring_has_agent_attribute("request.parameters.duly")
   end
 
+  def test_agent_attributes_assigned_from_request
+    request = stub(
+      :path => "/",
+      :referer => "http://docs.newrelic.com",
+      :env => {"HTTP_ACCEPT" => "application/json"},
+      :content_length => 103,
+      :host => 'chippy',
+      :user_agent => 'Use This!',
+      :request_method => "GET"
+    )
+
+    run_transaction({}, {:request => request}) do |txn|
+    end
+
+    assert_error_has_agent_attribute "request.headers.referer", "http://docs.newrelic.com"
+    refute_transaction_trace_has_agent_attribute "request.headers.referer"
+    refute_event_has_agent_attribute "request.headers.referer"
+    refute_browser_monitoring_has_agent_attribute "request.headers.referer"
+
+    assert_transaction_trace_has_agent_attribute "request.headers.accept", "application/json"
+    assert_event_has_agent_attribute "request.headers.accept", "application/json"
+    assert_error_has_agent_attribute "request.headers.accept", "application/json"
+    refute_browser_monitoring_has_agent_attribute "request.headers.accept"
+
+    assert_transaction_trace_has_agent_attribute "request.headers.contentLength", 103
+    assert_event_has_agent_attribute "request.headers.contentLength", 103
+    assert_error_has_agent_attribute "request.headers.contentLength", 103
+    refute_browser_monitoring_has_agent_attribute "request.headers.contentLength"
+
+    assert_transaction_trace_has_agent_attribute "request.headers.host", "chippy"
+    assert_event_has_agent_attribute "request.headers.host", "chippy"
+    assert_error_has_agent_attribute "request.headers.host", "chippy"
+    refute_browser_monitoring_has_agent_attribute "request.headers.host"
+
+    assert_transaction_trace_has_agent_attribute "request.headers.userAgent", "Use This!"
+    assert_event_has_agent_attribute "request.headers.userAgent", "Use This!"
+    assert_error_has_agent_attribute "request.headers.userAgent", "Use This!"
+    refute_browser_monitoring_has_agent_attribute "request.headers.userAgent"
+
+    assert_transaction_trace_has_agent_attribute "request.method", "GET"
+    assert_event_has_agent_attribute "request.method", "GET"
+    assert_error_has_agent_attribute "request.method", "GET"
+    refute_browser_monitoring_has_agent_attribute "request.method"
+  end
+
   def test_custom_attributes_included
     run_transaction do
       NewRelic::Agent.add_custom_attributes(:foo => 'bar')

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

@@ -39,9 +39,8 @@ class AuditLogTest < Minitest::Test
   def test_logs_request_bodies_human_readably_ish
     run_agent(:'audit_log.enabled' => true) do
       perform_actions
-      format = NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? :json : :pruby
       $collector.agent_data.each do |req|
-        assert_audit_log_contains_object(audit_log_contents, req.body, format)
+        assert_audit_log_contains_object(audit_log_contents, req.body)
       end
     end
   end

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

@@ -0,0 +1,82 @@
+# 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.
+
+class ErrorEventsTest < Minitest::Test
+  include MultiverseHelpers
+
+  setup_and_teardown_agent
+
+  def test_error_events_are_submitted
+    txn = generate_errors
+
+    NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
+
+    intrinsics, _, _ = last_error_event
+
+    assert_equal txn.best_name, intrinsics["transactionName"]
+    assert_equal "RuntimeError", intrinsics["error.class"]
+    assert_equal "Big Controller", intrinsics["error.message"]
+    assert_equal "TransactionError", intrinsics["type"]
+    if RUBY_VERSION == '1.8.7'
+      # 1.8 + JSON is finicky about comparing floats.
+      # If the timestamps are within 0.001 seconds, it's Good Enough.
+      assert_in_delta(txn.payload[:duration], intrinsics["duration"], 0.001)
+    else
+      assert_equal txn.payload[:duration], intrinsics["duration"]
+    end
+  end
+
+  def test_records_supportability_metrics
+    with_config :'error_collector.max_event_samples_stored' => 10 do
+      generate_errors 15
+
+      NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
+
+      assert_metrics_recorded({
+        "Supportability/Events/TransactionError/Sent" => {:call_count => 10},
+        "Supportability/Events/TransactionError/Seen" => {:call_count => 15}
+      })
+    end
+  end
+
+  def test_does_not_record_error_events_when_disabled
+    with_config :'error_collector.capture_events' => false do
+      generate_errors 5
+
+      NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
+      assert_equal(0, $collector.calls_for(:error_event_data).size)
+    end
+  end
+
+  def test_does_not_record_error_events_when_disabled_by_feature_gate
+    connect_response = {
+      'agent_run_id'          => 1,
+      'collect_error_events' => false
+    }
+
+    $collector.stub('connect', connect_response)
+    trigger_agent_reconnect
+
+    generate_errors 5
+
+    NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
+    assert_equal(0, $collector.calls_for(:error_event_data).size)
+  end
+
+  def generate_errors num_errors = 1
+    in_transaction :transaction_name => "Controller/blogs/index" do |t|
+      num_errors.times { t.notice_error RuntimeError.new "Big Controller" }
+    end
+  end
+
+  def last_error_event
+    post = last_error_event_post
+    assert_equal(1, post.error_events.size)
+    post.error_events.last
+  end
+
+  def last_error_event_post
+    $collector.calls_for(:error_event_data).first
+  end
+end

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

@@ -23,8 +23,15 @@ class HarvestTimestampsTest < Minitest::Test
     metric_data_post = $collector.calls_for('metric_data').first
     start_ts, end_ts = metric_data_post[1..2]
 
-    assert_equal(t1.to_f, start_ts)
-    assert_equal(t2.to_f, end_ts)
+    if RUBY_VERSION == '1.8.7'
+      # 1.8 + JSON is finicky about comparing floats.
+      # If the timestamps are within 0.001 seconds, it's Good Enough.
+      assert_in_delta(t1.to_f, start_ts, 0.001)
+      assert_in_delta(t2.to_f, end_ts, 0.001)
+    else
+      assert_equal(t1.to_f, start_ts)
+      assert_equal(t2.to_f, end_ts)
+    end
   end
 
   def test_start_timestamp_maintained_on_harvest_failure
@@ -43,8 +50,17 @@ class HarvestTimestampsTest < Minitest::Test
     trigger_metric_data_post
     second_post = last_metric_data_post
 
-    assert_equal([t0, t1], first_post[1..2])
-    assert_equal([t0, t2], second_post[1..2])
+    if RUBY_VERSION == '1.8.7'
+      # 1.8 + JSON is finicky about comparing floats.
+      # If the timestamps are within 0.001 seconds, it's Good Enough.
+      assert_in_delta(t0, first_post[1], 0.001)
+      assert_in_delta(t1, first_post[2], 0.001)
+      assert_in_delta(t0, second_post[1], 0.001)
+      assert_in_delta(t2, second_post[2], 0.001)
+    else
+      assert_equal([t0, t1], first_post[1..2])
+      assert_equal([t0, t2], second_post[1..2])
+    end
   end
 
   def test_timestamps_updated_even_if_filling_metric_id_cache_fails
@@ -65,8 +81,17 @@ class HarvestTimestampsTest < Minitest::Test
     trigger_metric_data_post
     second_post = last_metric_data_post
 
-    assert_equal([t0, t1], first_post[1..2])
-    assert_equal([t1, t2], second_post[1..2])
+    if RUBY_VERSION == '1.8.7'
+      # 1.8 + JSON is finicky about comparing floats.
+      # If the timestamps are within 0.001 seconds, it's Good Enough.
+      assert_in_delta(t0, first_post[1], 0.001)
+      assert_in_delta(t1, first_post[2], 0.001)
+      assert_in_delta(t1, second_post[1], 0.001)
+      assert_in_delta(t2, second_post[2], 0.001)
+    else
+      assert_equal([t0, t1], first_post[1..2])
+      assert_equal([t1, t2], second_post[1..2])
+    end
   end
 
   def trigger_metric_data_post