newrelic_rpm 3.13.2.302 → 3.14.0.305

data/lib/new_relic/agent/error_trace_aggregator.rb

@@ -10,6 +10,11 @@ module NewRelic
         @capacity = capacity
         @lock = Mutex.new
         @errors = []
+        register_config_callbacks
+      end
+
+      def enabled?
+        Agent.config[:'error_collector.enabled']
       end
 
       def merge!(errors)
@@ -38,6 +43,7 @@ module NewRelic
       # the error queue is too long - if so, we drop the error on the
       # floor after logging a warning.
       def add_to_error_queue(noticed_error)
+        return unless enabled?
         @lock.synchronize do
           if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
             @errors << noticed_error
@@ -49,14 +55,12 @@ module NewRelic
       # the maximum limit, and logs a warning if we are over the limit.
       def over_queue_limit?(message)
         over_limit = (@errors.reject{|err| err.is_internal}.length >= @capacity)
-        ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{@capacity}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}") if over_limit
+        if over_limit
+          ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{@capacity}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}")
+        end
         over_limit
       end
 
-      def errors
-        @lock.synchronize{ @errors }
-      end
-
       # *Use sparingly for difficult to track bugs.*
       #
       # Track internal agent errors for communication back to New Relic.
@@ -84,6 +88,12 @@ module NewRelic
       rescue => e
         NewRelic::Agent.logger.info("Unable to capture internal agent error due to an exception:", e)
       end
+
+      def register_config_callbacks
+        Agent.config.register_callback(:'error_collector.enabled') do |enabled|
+          ::NewRelic::Agent.logger.debug "Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service."
+        end
+      end
     end
   end
 end

data/lib/new_relic/agent/instrumentation/middleware_tracing.rb

@@ -55,6 +55,17 @@ module NewRelic
           end
         end
 
+        # the trailing unless is for the benefit for Ruby 1.8.7 and can be removed
+        # when it is deprecated.
+        CONTENT_TYPE = 'Content-Type'.freeze unless defined?(CONTENT_TYPE)
+
+        def capture_response_content_type(state, result)
+          if result.is_a?(Array) && state.current_transaction
+            _, headers, _ = result
+            state.current_transaction.response_content_type = headers[CONTENT_TYPE]
+          end
+        end
+
         def call(env)
           first_middleware = note_transaction_started(env)
 
@@ -66,8 +77,11 @@ module NewRelic
 
             result = (target == self) ? traced_call(env) : target.call(env)
 
-            capture_http_response_code(state, result)
-            events.notify(:after_call, env, result) if first_middleware
+            if first_middleware
+              capture_http_response_code(state, result)
+              capture_response_content_type(state, result)
+              events.notify(:after_call, env, result)
+            end
 
             result
           rescue Exception => e

data/lib/new_relic/agent/new_relic_service.rb

@@ -7,7 +7,6 @@ require 'new_relic/agent/audit_logger'
 require 'new_relic/agent/new_relic_service/encoders'
 require 'new_relic/agent/new_relic_service/marshaller'
 require 'new_relic/agent/new_relic_service/json_marshaller'
-require 'new_relic/agent/new_relic_service/pruby_marshaller'
 
 module NewRelic
   module Agent
@@ -56,16 +55,11 @@ module NewRelic
         end
 
         Agent.config.register_callback(:marshaller) do |marshaller|
-          begin
-            if marshaller == 'json'
-              @marshaller = JsonMarshaller.new
-            else
-              @marshaller = PrubyMarshaller.new
-            end
-          rescue LoadError
-            ::NewRelic::Agent.logger.warn("JSON marshaller requested, but the 'json' gem was not available, falling back to pruby. This will not be supported in future versions of the agent.")
-            @marshaller = PrubyMarshaller.new
+          if marshaller != 'json'
+            ::NewRelic::Agent.logger.warn("Non-JSON marshaller '#{marshaller}' requested but not supported, using JSON marshaller instead. pruby marshalling has been removed as of version 3.14.0.")
           end
+
+          @marshaller = JsonMarshaller.new
         end
       end
 
@@ -185,6 +179,13 @@ module NewRelic
           :item_count => data.size)
       end
 
+      def error_event_data(data)
+        metadata, items = data
+        invoke_remote(:error_event_data, [@agent_id, *data], :item_count => items.size)
+        NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Sent", :count => items.size)
+        NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Seen", :count => metadata[:events_seen])
+      end
+
       # We do not compress if content is smaller than 64kb.  There are
       # problems with bugs in Ruby in some versions that expose us
       # to a risk of segfaults if we compress aggressively.

data/lib/new_relic/agent/new_relic_service/json_marshaller.rb

@@ -12,7 +12,7 @@ module NewRelic
         def initialize
           ::NewRelic::Agent.logger.debug "Using JSON marshaller (#{NewRelic::JSONWrapper.backend_name})"
           unless self.class.is_supported?
-            ::NewRelic::Agent.logger.warn "The JSON marshaller in use (#{NewRelic::JSONWrapper.backend_name}) is not recommended. Ensure the 'json' gem is available in your application for better performance."
+            ::NewRelic::Agent.logger.error "JSON backend #{NewRelic::JSONWrapper.backend_name} is not supported."
           end
           warn_for_yajl
         end

data/lib/new_relic/agent/payload_metric_mapping.rb

@@ -0,0 +1,58 @@
+# -*- ruby -*-
+# 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.
+
+module NewRelic
+  module Agent
+    module PayloadMetricMapping
+
+      # this logic was extracted from TransactionEventAggregator for reuse by
+      # the ErrorEventAggregator
+
+      SPEC_MAPPINGS = {}
+
+      class << self
+        def append_mapped_metrics(txn_metrics, sample)
+          if txn_metrics
+            SPEC_MAPPINGS.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
+
+        private
+
+        def map_metric(metric_name, to_add={})
+          to_add.values.each(&:freeze)
+
+          mappings = SPEC_MAPPINGS.fetch(metric_name, {})
+          mappings.merge!(to_add)
+
+          SPEC_MAPPINGS[metric_name] = mappings
+        end
+      end
+
+      # 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')
+    end
+  end
+end

data/lib/new_relic/agent/sampled_buffer.rb

@@ -26,13 +26,22 @@ module NewRelic
         super
       end
 
-      def append_event(x)
+      def append(x = nil, &blk)
+        @seen += 1
+        append_event(x, &blk)
+      end
+
+      def append_event(x = nil, &blk)
+        raise ArgumentError, "Expected argument or block, but received both" if x && blk
+
         if @items.size < @capacity
+          x = blk.call if block_given?
           @items << x
           return x
         else
           m = rand(@seen) # [0, @seen)
           if m < @capacity
+            x = blk.call if block_given?
             @items[m] = x
             return x
           else
@@ -42,6 +51,11 @@ module NewRelic
         end
       end
 
+      def decrement_lifetime_counts_by n
+        @captured_lifetime -= n
+        @seen_lifetime -= n
+      end
+
       def sample_rate_lifetime
         @captured_lifetime > 0 ? (@captured_lifetime.to_f / @seen_lifetime) : 0.0
       end

data/lib/new_relic/agent/supported_versions.rb

@@ -12,18 +12,18 @@ module NewRelic
         :type        => :ruby,
         :name        => "MRI",
         :supported   => ["1.8.7", "1.9.2", "1.9.3", "2.0.0", "~> 2.1.0", "~> 2.2.0" ],
-        :deprecated  => ["1.8.6"],
         :url         => "https://www.ruby-lang.org",
         :feed        => "https://www.ruby-lang.org/en/feeds/news.rss",
         :notes       => [
-          "1.8.7 includes support for Ruby Enterprise Edition (REE)",
-          "Last supported agent on 1.8.6 was 3.6.8.168"]
+          "1.8.7 includes support for Ruby Enterprise Edition (REE).",
+          "1.8.7 & REE require the 'json' gem to be present in your Gemfile/operating environment.",
+          "Last supported agent on 1.8.6 was 3.6.8.168."]
       },
       :jruby =>
       {
         :type        => :ruby,
         :name        => "JRuby",
-        :supported   => ["~> 1.6.0", "~> 1.7.0"],
+        :supported   => ["~> 1.6.0", "~> 1.7.0", "~> 9.0"],
         :url         => "http://jruby.org",
         :feed        => "http://jruby.org/atom.xml"
       },

data/lib/new_relic/agent/transaction.rb

@@ -7,6 +7,7 @@ require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/transaction_metrics'
 require 'new_relic/agent/method_tracer_helpers'
 require 'new_relic/agent/transaction/attributes'
+require 'new_relic/agent/transaction/request_attributes'
 
 module NewRelic
   module Agent
@@ -51,7 +52,8 @@ module NewRelic
                     :filtered_params,
                     :jruby_cpu_start,
                     :process_cpu_start,
-                    :http_response_code
+                    :http_response_code,
+                    :response_content_type
 
       attr_reader :guid,
                   :metrics,
@@ -60,8 +62,7 @@ module NewRelic
                   :frame_stack,
                   :cat_path_hashes,
                   :attributes,
-                  :request_path,
-                  :referer
+                  :payload
 
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
@@ -282,16 +283,31 @@ module NewRelic
         @ignore_enduser = false
         @ignore_trace = false
 
+        @error_recorded = false
+
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
 
         merge_request_parameters(@filtered_params)
 
         if request = options[:request]
-          @request_path = path_from_request(request)
-          @referer = referer_from_request(request)
+          @request_attributes = RequestAttributes.new request
+        else
+          @request_attributes = nil
         end
       end
 
+      def referer
+        @request_attributes && @request_attributes.referer
+      end
+
+      def request_path
+        @request_attributes && @request_attributes.request_path
+      end
+
+      def request_port
+        @request_attributes && @request_attributes.port
+      end
+
       # This transaction-local hash may be used as temprory storage by
       # instrumentation that needs to pass data from one instrumentation point
       # to another.
@@ -507,23 +523,28 @@ module NewRelic
         record_apdex(state, end_time) unless ignore_apdex?
         record_queue_time
 
+        generate_payload(state, start_time, end_time)
         record_exceptions
         merge_metrics
 
-        send_transaction_finished_event(state, start_time, end_time)
+        send_transaction_finished_event
       end
 
       def assign_agent_attributes
-        if referer
-          add_agent_attribute(:'request.headers.referer', referer,
-                              NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
-        end
+        default_destinations = AttributeFilter::DST_TRANSACTION_TRACER |
+                               AttributeFilter::DST_TRANSACTION_EVENTS |
+                               AttributeFilter::DST_ERROR_COLLECTOR
 
         if http_response_code
-          add_agent_attribute(:httpResponseCode, http_response_code.to_s,
-                              NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER|
-                              NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS|
-                              NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
+          add_agent_attribute(:httpResponseCode, http_response_code.to_s, default_destinations)
+        end
+
+        if response_content_type
+          add_agent_attribute(:'response.headers.contentType', response_content_type, default_destinations)
+        end
+
+        if @request_attributes
+          @request_attributes.assign_agent_attributes self
         end
       end
 
@@ -563,22 +584,25 @@ module NewRelic
 
       # This event is fired when the transaction is fully completed. The metric
       # values and sampler can't be successfully modified from this event.
-      def send_transaction_finished_event(state, start_time, end_time)
+      def send_transaction_finished_event
+        agent.events.notify(:transaction_finished, payload)
+      end
+
+      def generate_payload(state, start_time, end_time)
         duration = end_time.to_f - start_time.to_f
-        payload = {
+        @payload = {
           :name                 => @frozen_name,
           :bucket               => recording_web_transaction? ? :request : :background,
           :start_timestamp      => start_time.to_f,
           :duration             => duration,
           :metrics              => @metrics,
           :attributes           => @attributes,
+          :error                => error_recorded?
         }
-        append_cat_info(state, duration, payload)
-        append_apdex_perf_zone(duration, payload)
-        append_synthetics_to(state, payload)
-        append_referring_transaction_guid_to(state, payload)
-
-        agent.events.notify(:transaction_finished, payload)
+        append_cat_info(state, duration, @payload)
+        append_apdex_perf_zone(duration, @payload)
+        append_synthetics_to(state, @payload)
+        append_referring_transaction_guid_to(state, @payload)
       end
 
       def include_guid?(state, duration)
@@ -703,10 +727,11 @@ module NewRelic
       def record_exceptions
         @exceptions.each do |exception, options|
           options[:uri]      ||= request_path if request_path
+          options[:port]       = request_port if request_port
           options[:metric]     = best_name
           options[:attributes] = @attributes
 
-          agent.error_collector.notice_error(exception, options)
+          @error_recorded = !!agent.error_collector.notice_error(exception, options) || @error_recorded
         end
       end
 
@@ -719,6 +744,10 @@ module NewRelic
         end
       end
 
+      def error_recorded?
+        @error_recorded
+      end
+
       QUEUE_TIME_METRIC = 'WebFrontend/QueueTime'.freeze
 
       def queue_time
@@ -916,27 +945,6 @@ module NewRelic
         end
         guid
       end
-
-      # Make a safe attempt to get the referer from a request object, generally successful when
-      # it's a Rack request.
-      def referer_from_request(req)
-        if req && req.respond_to?(:referer) && req.referer
-          HTTPClients::URIUtil.strip_query_string(req.referer.to_s)
-        end
-      end
-
-      # In practice we expect req to be a Rack::Request or ActionController::AbstractRequest
-      # (for older Rails versions).  But anything that responds to path can be passed to
-      # perform_action_with_newrelic_trace.
-      #
-      # We don't expect the path to include a query string, however older test helpers for
-      # rails construct the PATH_INFO enviroment variable improperly and we're generally
-      # being defensive.
-      def path_from_request(req)
-        path = req.path
-        path = HTTPClients::URIUtil.strip_query_string(path)
-        path.empty? ? "/" : path
-      end
     end
   end
 end

data/lib/new_relic/agent/transaction/request_attributes.rb

@@ -0,0 +1,110 @@
+# 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 'new_relic/agent/http_clients/uri_util'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class RequestAttributes
+        attr_reader :request_path, :referer, :accept, :content_length, :host,
+                    :port, :user_agent, :request_method
+
+        HTTP_ACCEPT_HEADER_KEY = "HTTP_ACCEPT".freeze
+
+        def initialize request
+          @request_path = path_from_request request
+          @referer = referer_from_request request
+          @accept = attribute_from_env request, HTTP_ACCEPT_HEADER_KEY
+          @content_length = content_length_from_request request
+          @host = attribute_from_request request, :host
+          @port = port_from_request request
+          @user_agent = attribute_from_request request, :user_agent
+          @request_method = attribute_from_request request, :request_method
+        end
+
+        def assign_agent_attributes txn
+         default_destinations = AttributeFilter::DST_TRANSACTION_TRACER|
+                                AttributeFilter::DST_TRANSACTION_EVENTS|
+                                AttributeFilter::DST_ERROR_COLLECTOR
+
+          if referer
+            txn.add_agent_attribute :'request.headers.referer', referer, AttributeFilter::DST_ERROR_COLLECTOR
+          end
+
+          if accept
+            txn.add_agent_attribute :'request.headers.accept', accept, default_destinations
+          end
+
+          if content_length
+            txn.add_agent_attribute :'request.headers.contentLength', content_length, default_destinations
+          end
+
+          if host
+            txn.add_agent_attribute :'request.headers.host', host, default_destinations
+          end
+
+          if user_agent
+            txn.add_agent_attribute :'request.headers.userAgent', user_agent, default_destinations
+          end
+
+          if request_method
+            txn.add_agent_attribute :'request.method', request_method, default_destinations
+          end
+        end
+
+        private
+
+        # Make a safe attempt to get the referer from a request object, generally successful when
+        # it's a Rack request.
+
+        def referer_from_request request
+          if referer = attribute_from_request(request, :referer)
+            HTTPClients::URIUtil.strip_query_string referer.to_s
+          end
+        end
+
+        # In practice we expect req to be a Rack::Request or ActionController::AbstractRequest
+        # (for older Rails versions).  But anything that responds to path can be passed to
+        # perform_action_with_newrelic_trace.
+        #
+        # We don't expect the path to include a query string, however older test helpers for
+        # rails construct the PATH_INFO enviroment variable improperly and we're generally
+        # being defensive.
+
+        ROOT_PATH = "/".freeze
+
+        def path_from_request request
+          path = attribute_from_request(request, :path) || ''
+          path = HTTPClients::URIUtil.strip_query_string(path)
+          path.empty? ? ROOT_PATH : path
+        end
+
+        def content_length_from_request request
+          if content_length = attribute_from_request(request, :content_length)
+            content_length.to_i
+          end
+        end
+
+        def port_from_request request
+          if port = attribute_from_request(request, :port)
+            port.to_i
+          end
+        end
+
+        def attribute_from_request request, attribute_method
+          if request.respond_to? attribute_method
+            request.send(attribute_method)
+          end
+        end
+
+        def attribute_from_env request, key
+          if env = attribute_from_request(request, :env)
+            env[key]
+          end
+        end
+      end
+    end
+  end
+end