newrelic_rpm 3.6.4.122 → 3.6.5.130

data/lib/new_relic/agent/{uri_util.rb → http_clients/uri_util.rb}

@@ -11,25 +11,19 @@
 
 module NewRelic
   module Agent
-    module URIUtil
-      def self.uri_from_connection_and_request(http, request)
-        parsed = case request.path
-        when /^https?:\/\//
-          URI(request.path)
-        else
-          scheme = http.use_ssl? ? 'https' : 'http'
-          URI("#{scheme}://#{http.address}:#{http.port}#{request.path}")
+    module HTTPClients
+      module URIUtil
+
+        def self.filter_uri(original)
+          filtered = original.dup
+          filtered.user = nil
+          filtered.password = nil
+          filtered.query = nil
+          filtered.fragment = nil
+          filtered.to_s
         end
-      end
 
-      def self.filtered_uri_for(http, request)
-        parsed = uri_from_connection_and_request(http, request)
-        parsed.user = nil
-        parsed.password = nil
-        parsed.query = nil
-        parsed.fragment = nil
-        parsed.to_s
       end
     end
   end
-end
+end

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

@@ -63,8 +63,8 @@ module NewRelic
           txn = Transaction.current
           metrics = [ 'HttpDispatcher']
           if txn.has_parent?
-            controller_metric.scope = StatsEngine::MetricStats::SCOPE_PLACEHOLDER
-            record_metric_on_parent_transaction(controller_metric, event.duration)
+            parent_metric = MetricSpec.new(event.metric_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)
+            record_metric_on_parent_transaction(parent_metric, event.duration)
           end
           metrics << controller_metric.dup
 
@@ -72,19 +72,12 @@ module NewRelic
         end
 
         def record_metric_on_parent_transaction(metric, time)
-          txn = NewRelic::Agent::Transaction.current
-          txn.parent.stats_hash.record(metric, time)
+          NewRelic::Agent::Transaction.parent.stats_hash.record(metric, time)
         end
 
         def record_apdex(event)
           return if event.apdex_ignored?
-          metric_parser = MetricParser::MetricParser \
-            .for_metric_named(event.metric_name)
-          duration_plus_queue_time = event.end - (event.queue_start || event.time)
-          Transaction.record_apdex(metric_parser,
-                                   event.duration,
-                                   duration_plus_queue_time,
-                                   event.exception_encountered?)
+          Transaction.record_apdex(event.end, event.exception_encountered?)
         end
 
         def record_instance_busy(event)

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

@@ -82,7 +82,7 @@ module NewRelic
         end
 
         def active_record_config_for_event(event)
-          return unless event.payload[:connection_id]
+          return unless event.payload[:connection_id] && NewRelic::LanguageSupport.object_space_enabled?
 
           # TODO: This will not work for JRuby and in any case we want
           # this to be part of the event meta data so it doesn't have

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

@@ -339,7 +339,7 @@ module NewRelic
 
             NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped.trace_execution_scoped_footer(txn.start_time.to_f, txn_name, metric_names, expected_scope, options, end_time.to_f)
             NewRelic::Agent::BusyCalculator.dispatcher_finish(end_time)
-            txn.record_apdex(txn_name, end_time) unless ignore_apdex?
+            txn.record_apdex(end_time) unless ignore_apdex?
             txn = Transaction.stop(txn_name, end_time)
 
             NewRelic::Agent::TransactionInfo.get.ignore_end_user = true if ignore_enduser?
@@ -443,7 +443,7 @@ module NewRelic
           txn = Transaction.start(category, options)
           txn.name = TransactionNamer.new(self).name(options)
 
-          txn.apdex_start ||= _detect_upstream_wait(txn.start_time)
+          txn.apdex_start = _detect_upstream_wait(txn.start_time)
           _record_queue_length
 
           return txn

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

@@ -0,0 +1,72 @@
+# 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.
+
+DependencyDetection.defer do
+  named :excon
+
+  # We have two ways of instrumenting Excon:
+  # - For newer versions, use the middleware mechanism Excon exposes
+  # - For older versions, monkey-patch Excon::Connection#request
+  #
+  # EXCON_MIN_VERSION is the minimum version we attempt to instrument at all.
+  # EXCON_MIDDLEWARE_MIN_VERSION is the min version we use the newer
+  #   instrumentation for.
+  #
+  # Note that middlewares were added to Excon prior to 0.19, but we don't
+  # use middleware-based instrumentation prior to that version because it didn't
+  # expose a way for middlewares to know about request failures.
+  #
+  # Why don't we use Excon.defaults[:instrumentor]?
+  # While this might seem a perfect fit, it unfortunately isn't suitable in
+  # current form. Someone might reasonably set the default instrumentor to
+  # something else after we install our instrumentation. Ideally, excon would
+  # itself conform to the #subscribe interface of ActiveSupport::Notifications,
+  # so we could safely subscribe and not be clobbered by future subscribers,
+  # but alas, it does not yet.
+
+  EXCON_MIN_VERSION = ::NewRelic::VersionNumber.new("0.10.1")
+  EXCON_MIDDLEWARE_MIN_VERSION = ::NewRelic::VersionNumber.new("0.19.0")
+
+  depends_on do
+    defined?(::Excon) && defined?(::Excon::VERSION)
+  end
+
+  executes do
+    excon_version = NewRelic::VersionNumber.new(::Excon::VERSION)
+    if excon_version >= EXCON_MIN_VERSION
+      install_excon_instrumentation(excon_version)
+    else
+      ::NewRelic::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MIN_VERSION}")
+    end
+  end
+
+  def install_excon_instrumentation(excon_version)
+    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/http_clients/excon_wrappers'
+
+    if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION
+      install_middleware_excon_instrumentation
+    else
+      install_legacy_excon_instrumentation
+    end
+  end
+
+  def install_middleware_excon_instrumentation
+    ::NewRelic::Agent.logger.info 'Installing middleware-based Excon instrumentation'
+    require 'new_relic/agent/instrumentation/excon/middleware'
+    defaults = Excon.defaults
+
+    if defaults[:middlewares]
+      defaults[:middlewares] << ::Excon::Middleware::NewRelicCrossAppTracing
+    else
+      ::NewRelic::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
+    end
+  end
+
+  def install_legacy_excon_instrumentation
+    ::NewRelic::Agent.logger.info 'Installing legacy Excon instrumentation'
+    require 'new_relic/agent/instrumentation/excon/connection'
+    ::Excon::Connection.install_newrelic_instrumentation
+  end
+end

data/lib/new_relic/agent/instrumentation/excon/connection.rb

@@ -0,0 +1,33 @@
+# 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 ::Excon
+  class Connection
+    def newrelic_connection_params
+      (@connection || @data)
+    end
+
+    def newrelic_resolved_request_params(request_params)
+      resolved = newrelic_connection_params.merge(request_params)
+      resolved[:headers] = resolved[:headers].merge(request_params[:headers] || {})
+      resolved
+    end
+
+    def request_with_newrelic_trace(params, &block)
+      orig_response = nil
+      resolved_params = newrelic_resolved_request_params(params)
+      wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(resolved_params)
+      ::NewRelic::Agent::CrossAppTracing.trace_http_request(wrapped_request) do
+        orig_response = request_without_newrelic_trace(resolved_params, &block)
+        ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(orig_response)
+      end
+      orig_response
+    end
+
+    def self.install_newrelic_instrumentation
+      alias request_without_newrelic_trace request
+      alias request request_with_newrelic_trace
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/excon/middleware.rb

@@ -0,0 +1,45 @@
+# 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 ::Excon
+  module Middleware
+    class NewRelicCrossAppTracing
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def request_call(datum)
+        begin
+          wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
+          t0, segment = ::NewRelic::Agent::CrossAppTracing.start_trace(wrapped_request)
+          datum[:newrelic_trace_data] = [t0, segment, wrapped_request]
+        rescue => e
+          NewRelic::Agent.logger.debug(e)
+        end
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        finish_trace(datum)
+        @stack.response_call(datum)
+      end
+
+      def error_call(datum)
+        finish_trace(datum)
+        @stack.error_call(datum)
+      end
+
+      def finish_trace(datum)
+        trace_data = datum.delete(:newrelic_trace_data)
+        if trace_data
+          t0, segment, wrapped_request = trace_data
+          if datum[:response]
+            wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
+          end
+          ::NewRelic::Agent::CrossAppTracing.finish_trace(t0, segment, wrapped_request, wrapped_response)
+        end
+      end
+    end
+  end
+end

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

@@ -12,6 +12,7 @@ DependencyDetection.defer do
   executes do
     ::NewRelic::Agent.logger.info 'Installing Net instrumentation'
     require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/http_clients/net_http_wrappers'
   end
 
   executes do
@@ -24,7 +25,8 @@ DependencyDetection.defer do
       # Don't tracing until the inner call then to avoid double-counting.
       def request_with_newrelic_trace(request, *args, &block)
         if started?
-          NewRelic::Agent::CrossAppTracing.trace_http_request( self, request ) do
+          wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+          NewRelic::Agent::CrossAppTracing.trace_http_request( wrapped_request ) do
             request_without_newrelic_trace( request, *args, &block )
           end
         else

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

@@ -0,0 +1,73 @@
+# 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.
+
+DependencyDetection.defer do
+  named :typhoeus
+
+  depends_on do
+    defined?(Typhoeus) && defined?(Typhoeus::VERSION)
+  end
+
+  depends_on do
+    NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Typhoeus instrumentation'
+    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/http_clients/typhoeus_wrappers'
+  end
+
+  # Basic request tracing
+  executes do
+    Typhoeus.before do |request|
+      NewRelic::Agent::Instrumentation::TyphoeusTracing.trace(request)
+
+      # Ensure that we always return a truthy value from the before block,
+      # otherwise Typhoeus will bail out of the instrumentation.
+      true
+    end
+  end
+
+  # Apply single TT node for Hydra requests until async support
+  executes do
+    class Typhoeus::Hydra
+      include NewRelic::Agent::MethodTracer
+
+      def run_with_newrelic(*args)
+        trace_execution_scoped("External/Multiple/Typhoeus::Hydra/run") do
+          run_without_newrelic(*args)
+        end
+      end
+
+      alias run_without_newrelic run
+      alias run run_with_newrelic
+    end
+  end
+end
+
+
+module NewRelic::Agent::Instrumentation::TyphoeusTracing
+
+  EARLIEST_VERSION = NewRelic::VersionNumber.new("0.5.3")
+
+  def self.is_supported_version?
+    NewRelic::VersionNumber.new(Typhoeus::VERSION) >= NewRelic::Agent::Instrumentation::TyphoeusTracing::EARLIEST_VERSION
+  end
+
+  def self.request_is_hydra_enabled?(request)
+    request.respond_to?(:hydra) && request.hydra
+  end
+
+  def self.trace(request)
+    if NewRelic::Agent.is_execution_traced? && !request_is_hydra_enabled?(request)
+      wrapped_request = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(request)
+      t0, segment = ::NewRelic::Agent::CrossAppTracing.start_trace(wrapped_request)
+      request.on_complete do
+        wrapped_response = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
+        ::NewRelic::Agent::CrossAppTracing.finish_trace(t0, segment, wrapped_request, wrapped_response)
+      end if t0
+    end
+  end
+end

data/lib/new_relic/agent/method_tracer.rb

@@ -219,15 +219,12 @@ module NewRelic
 
           def record_metrics(first_name, other_names, duration, exclusive, options)
             metrics = metrics_for_current_transaction(first_name, other_names, options)
-            stat_engine.record_metrics(metrics) do |stat|
-              stat.record_data_point(duration, exclusive)
-            end
+            stat_engine.record_metrics_internal(metrics, duration, exclusive)
 
             parent_metrics = metrics_for_parent_transaction(first_name, options)
             parent_metrics.each do |metric|
-              NewRelic::Agent::Transaction.parent.stats_hash.record(metric) do |stats|
-                stats.record_data_point(duration, exclusive)
-              end
+              parent_txn = NewRelic::Agent::Transaction.parent
+              parent_txn.stats_hash.record(metric, duration, exclusive)
             end
           end
 

data/lib/new_relic/agent/new_relic_service.rb

@@ -345,7 +345,7 @@ module NewRelic
         response
       rescue SystemCallError, SocketError => e
         # These include Errno connection errors
-        raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to the server: #{e}"
+        raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to #{@collector}: #{e}"
       end
 
 

data/lib/new_relic/agent/samplers/object_sampler.rb

@@ -13,7 +13,7 @@ module NewRelic
         end
 
         def self.supported_on_this_platform?
-          defined?(ObjectSpace) && ObjectSpace.respond_to?(:live_objects)
+          NewRelic::LanguageSupport.object_space_enabled? && ObjectSpace.respond_to?(:live_objects)
         end
 
         def poll

data/lib/new_relic/agent/stats.rb

@@ -117,16 +117,18 @@ module NewRelic
       alias_method :apdex_t, :total_call_time
       alias_method :apdex_f, :total_exclusive_time
 
-      def record_apdex_s
-        @call_count += 1
-      end
-
-      def record_apdex_t
-        @total_call_time += 1
-      end
-
-      def record_apdex_f
-        @total_exclusive_time += 1
+      def record_apdex(bucket, apdex_t)
+        case bucket
+        when :apdex_s then @call_count += 1
+        when :apdex_t then @total_call_time += 1
+        when :apdex_f then @total_exclusive_time += 1
+        end
+        if apdex_t
+          @min_call_time = apdex_t
+          @max_call_time = apdex_t
+        else
+          ::NewRelic::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+        end
       end
 
       protected

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -15,14 +15,13 @@ module NewRelic
         #
         # This method is thead-safe, and is preferred to the lookup / modify
         # method pairs (e.g. get_stats + record_data_point)
+        #
+        # @api private
         def record_metrics(metric_names_or_specs, value=nil, options={}, &blk)
-          defaults = {
-            :scoped => false,
-            :scope => in_transaction? ? SCOPE_PLACEHOLDER : nil
-          }
-          options = defaults.merge(options)
+          scoped = options[:scoped]
+          scope = in_transaction? ? SCOPE_PLACEHOLDER : nil
+          effective_scope = scoped && scope
 
-          effective_scope = options[:scoped] && options[:scope]
           specs = coerce_to_metric_spec_array(metric_names_or_specs, effective_scope)
 
           if in_transaction?
@@ -34,6 +33,25 @@ module NewRelic
           end
         end
 
+        # Fast-path version of the #record_metrics version above, used in
+        # performance-sensitive code paths
+        #
+        # metric_specs must be an Array of MetricSpec objects
+        # value and aux are passed directly to the corresponding parameters of
+        # StatsHash#record
+        #
+        # @api private
+        def record_metrics_internal(metric_specs, value, aux)
+          tsh = transaction_stats_hash
+          if tsh
+            tsh.record(metric_specs, value, aux)
+          else
+            with_stats_lock do
+              @stats_hash.record(metric_specs, value, aux)
+            end
+          end
+        end
+
         # a simple accessor for looking up a stat with no scope -
         # returns a new stats object if no stats object for that
         # metric exists yet