newrelic_rpm 3.6.4.122 → 3.6.5.130

data/CHANGELOG

@@ -1,5 +1,18 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.6.5 ##
+
+  * Rails 4.0 Support
+
+  The Ruby agent is all set for the recent general release of Rails 4.0! We've
+  been tracking the RC's, and that work paid off. Versions 3.6.5 and 3.6.4 of
+  the Ruby agent should work fine with Rails 4.0.0.
+
+  * Excon and Typhoeus support
+
+  The Ruby agent now supports the Excon and Typhoeus HTTP libraries! For more
+  details see https://newrelic.com/docs/ruby/ruby-http-clients.
+
 ## v3.6.4 ##
 
   * Exception Whitelist
@@ -21,7 +34,7 @@
   generation of the agent's EnvironmentReport on startup from a background
   thread to the main thread.
 
-## 3.6.3 ##
+## v3.6.3 ##
 
   * Better Sinatra Support
 

data/lib/new_relic/agent.rb

@@ -98,7 +98,7 @@ module NewRelic
     require 'new_relic/agent/transaction_info'
     require 'new_relic/agent/configuration'
     require 'new_relic/agent/rules_engine'
-    require 'new_relic/agent/uri_util'
+    require 'new_relic/agent/http_clients/uri_util'
     require 'new_relic/agent/system_info'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
@@ -186,12 +186,13 @@ module NewRelic
     def record_metric(metric_name, value)
       if value.is_a?(Hash)
         stats = NewRelic::Agent::Stats.new
-        stats.call_count = value[:count]
-        stats.total_call_time = value[:total]
-        stats.total_exclusive_time = value[:total]
-        stats.min_call_time = value[:min]
-        stats.max_call_time = value[:max]
-        stats.sum_of_squares = value[:sum_of_squares]
+
+        stats.call_count = value[:count] if value[:count]
+        stats.total_call_time = value[:total] if value[:total]
+        stats.total_exclusive_time = value[:total] if value[:total]
+        stats.min_call_time = value[:min] if value[:min]
+        stats.max_call_time = value[:max] if value[:max]
+        stats.sum_of_squares = value[:sum_of_squares] if value[:sum_of_squares]
         value = stats
       end
       agent.stats_engine.record_metrics(metric_name, value)

data/lib/new_relic/agent/agent.rb

@@ -53,6 +53,7 @@ module NewRelic
         @obfuscator = lambda {|sql| NewRelic::Agent::Database.default_sql_obfuscator(sql) }
 
         # FIXME: temporary work around for RUBY-839
+        # This should be handled with a configuration callback
         if Agent.config[:monitor_mode]
           @service = NewRelic::Agent::NewRelicService.new
         end
@@ -92,6 +93,7 @@ module NewRelic
         # cross application tracing ids and encoding
         attr_reader :cross_process_id
         attr_reader :cross_app_encoding_bytes
+        attr_reader :cross_app_monitor
         # service for communicating with collector
         attr_accessor :service
         # Global events dispatcher. This will provides our primary mechanism

data/lib/new_relic/agent/configuration/defaults.rb

@@ -148,7 +148,7 @@ module NewRelic
 
         :marshaller => Proc.new { NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported? ? 'json' : 'pruby' },
 
-        :'request_sampler.enabled'        => false,
+        :'request_sampler.enabled'        => true,
         :'request_sampler.sample_rate_ms' => 50
       ].freeze
     end

data/lib/new_relic/agent/configuration/server_source.rb

@@ -32,7 +32,8 @@ module NewRelic
           gated_features = {
             :'transaction_tracer.enabled' => 'collect_traces',
             :'slow_sql.enabled'           => 'collect_traces',
-            :'error_collector.enabled'    => 'collect_errors'
+            :'error_collector.enabled'    => 'collect_errors',
+            :'request_sampler.enabled'    => 'collect_analytics_events'
           }
           gated_features.each do |feature, gate_key|
             if server_config.has_key?(gate_key)

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -31,14 +31,18 @@ module NewRelic
 
       # Send the given +request+, adding metrics appropriate to the
       # response when it comes back.
-      def trace_http_request( http, request )
+      #
+      # See the documentation for +start_trace+ for an explanation of what
+      # +request+ should look like.
+      #
+      def trace_http_request( request )
         return yield unless NewRelic::Agent.is_execution_traced?
 
-        t0, segment = start_trace( http, request )
+        t0, segment = start_trace( request )
         begin
           response = yield
         ensure
-          finish_trace( t0, segment, request, response, http ) if t0
+          finish_trace( t0, segment, request, response ) if t0
         end
 
         return response
@@ -46,8 +50,19 @@ module NewRelic
 
 
       # Set up the necessary state for cross-application tracing before the
-      # given +request+ goes out on the specified +http+ connection.
-      def start_trace( http, request )
+      # given +request+ goes out.
+      #
+      # The +request+ object passed in must respond to the following methods:
+      #
+      # * type - Return a String describing the underlying library being used
+      #          to make the request (e.g. 'Net::HTTP' or 'Typhoeus')
+      # * host - Return a String with the hostname or IP of the host being
+      #          communicated with.
+      # * method  - Return a String with the HTTP method name used for this request
+      # * [](key) - Lookup an HTTP request header by name
+      # * []=(key, val) - Set an HTTP request header by name
+      # * uri  - Full URI of the request
+      def start_trace( request )
         inject_request_headers( request ) if cross_app_enabled?
 
         # Create a segment and time the call
@@ -63,15 +78,24 @@ module NewRelic
 
       # Finish tracing the HTTP +request+ that started at +t0+ with the information in
       # +response+ and the given +http+ connection.
-      def finish_trace( t0, segment, request, response, http )
+      #
+      # The +request+ must conform to the same interface described in the documentation
+      # for +start_trace+.
+      #
+      # The +response+ must respond to the following methods:
+      #
+      # * [](key) - Reads response headers.
+      # * to_hash - Converts response headers to a Hash
+      #
+      def finish_trace( t0, segment, request, response )
         t1 = Time.now
         duration = t1.to_f - t0.to_f
 
         begin
-          if request && response && http
+          if request
             # Figure out which metrics we need to report based on the request and response
             # The last (most-specific) one is scoped.
-            metrics = metrics_for( http, request, response )
+            metrics = metrics_for( request, response )
             scoped_metric = metrics.pop
 
             stats_engine.record_metrics(metrics, duration)
@@ -79,7 +103,7 @@ module NewRelic
 
             # Add TT custom parameters
             segment.name = scoped_metric
-            add_transaction_trace_parameters(http, request, response)
+            add_transaction_trace_parameters(request, response) if response
           end
         ensure
           # We always need to pop the scope stack to avoid an inconsistent
@@ -117,15 +141,15 @@ module NewRelic
         txn_guid = NewRelic::Agent::TransactionInfo.get.guid
         txn_data = NewRelic.json_dump([ txn_guid, false ])
 
-        request[ NR_ID_HEADER ] = obfuscate_with_key( key, cross_app_id )
+        request[ NR_ID_HEADER ]  = obfuscate_with_key( key, cross_app_id )
         request[ NR_TXN_HEADER ] = obfuscate_with_key( key, txn_data )
 
       rescue NewRelic::Agent::CrossAppTracing::Error => err
         NewRelic::Agent.logger.debug "Not injecting x-process header", err
       end
 
-      def add_transaction_trace_parameters(http, request, response)
-        filtered_uri = NewRelic::Agent::URIUtil.filtered_uri_for(http, request)
+      def add_transaction_trace_parameters(request, response)
+        filtered_uri = ::NewRelic::Agent::HTTPClients::URIUtil.filter_uri(request.uri)
         transaction_sampler.add_segment_parameters(:uri => filtered_uri)
         if response_is_crossapp?( response )
           add_cat_transaction_trace_parameters( response )
@@ -144,21 +168,23 @@ module NewRelic
 
       # Return the set of metric names that correspond to
       # the given +request+ and +response+.
-      def metrics_for( http, request, response )
-        metrics = common_metrics( http )
+      # +response+ may be nil in the case that the request produced an error
+      # without ever receiving an HTTP response.
+      def metrics_for( request, response )
+        metrics = common_metrics( request )
 
-        if response_is_crossapp?( response )
+        if response && response_is_crossapp?( response )
           begin
-            metrics.concat metrics_for_crossapp_response( http, response )
+            metrics.concat metrics_for_crossapp_response( request, response )
           rescue => err
             # Fall back to regular metrics if there's a problem with x-process metrics
             NewRelic::Agent.logger.debug "%p while fetching x-process metrics: %s" %
               [ err.class, err.message ]
-            metrics.concat metrics_for_regular_response( http, request, response )
+            metrics.concat metrics_for_regular_request( request )
           end
         else
           NewRelic::Agent.logger.debug "Response doesn't have CAT headers."
-          metrics.concat metrics_for_regular_response( http, request, response )
+          metrics.concat metrics_for_regular_request( request )
         end
 
         return metrics
@@ -166,9 +192,9 @@ module NewRelic
 
 
       # Return an Array of metrics used for every response.
-      def common_metrics( http )
+      def common_metrics( request )
         metrics = [ "External/all" ]
-        metrics << "External/#{http.address}/all"
+        metrics << "External/#{request.host}/all"
 
         if NewRelic::Agent::Transaction.recording_web_transaction?
           metrics << "External/allWeb"
@@ -196,7 +222,7 @@ module NewRelic
 
       # Return the set of metric objects appropriate for the given cross app
       # +response+.
-      def metrics_for_crossapp_response( http, response )
+      def metrics_for_crossapp_response( request, response )
         xp_id, txn_name, q_time, r_time, req_len, _ = extract_appdata( response )
 
         check_crossapp_id( xp_id )
@@ -205,8 +231,8 @@ module NewRelic
         NewRelic::Agent.logger.debug "CAT xp_id: %p, txn_name: %p." % [ xp_id, txn_name ]
 
         metrics = []
-        metrics << "ExternalApp/#{http.address}/#{xp_id}/all"
-        metrics << "ExternalTransaction/#{http.address}/#{xp_id}/#{txn_name}"
+        metrics << "ExternalApp/#{request.host}/#{xp_id}/all"
+        metrics << "ExternalTransaction/#{request.host}/#{xp_id}/#{txn_name}"
 
         return metrics
       end
@@ -238,10 +264,10 @@ module NewRelic
 
 
       # Return the set of metric objects appropriate for the given (non-cross app)
-      # +response+.
-      def metrics_for_regular_response( http, request, response )
+      # +request+.
+      def metrics_for_regular_request( request )
         metrics = []
-        metrics << "External/#{http.address}/Net::HTTP/#{request.method}"
+        metrics << "External/#{request.host}/#{request.type}/#{request.method}"
 
         return metrics
       end

data/lib/new_relic/agent/event_listener.rb

@@ -39,7 +39,7 @@ module NewRelic::Agent
         begin
           handler.call(*args)
         rescue => err
-          NewRelic::Agent.logger.debug("Failure during notify for #{@event}", err)
+          NewRelic::Agent.logger.debug("Failure during notify for #{event}", err)
         end
       end
     end

data/lib/new_relic/agent/http_clients/excon_wrappers.rb

@@ -0,0 +1,61 @@
+# 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 HTTPClients
+      class ExconHTTPResponse
+        def initialize(response)
+          @response = response
+          # Since HTTP headers are case-insensitive, we normalize all of them to
+          # upper case here, and then also in our [](key) implementation.
+          @normalized_headers = {}
+          headers = response.respond_to?(:headers) ? response.headers : response[:headers]
+          (headers || {}).each do |key, val|
+            @normalized_headers[key.upcase] = val
+          end
+        end
+
+        def [](key)
+          @normalized_headers[key.upcase]
+        end
+
+        def to_hash
+          @normalized_headers.dup
+        end
+      end
+
+      class ExconHTTPRequest
+        def initialize(datum)
+          @datum = datum
+        end
+
+        def type
+          "Excon"
+        end
+
+        def host
+          @datum[:host]
+        end
+
+        def method
+          @datum[:method].to_s.upcase
+        end
+
+        def [](key)
+          @datum[:headers][key]
+        end
+
+        def []=(key, value)
+          @datum[:headers] ||= {}
+          @datum[:headers][key] = value
+        end
+
+        def uri
+          URI.parse("#{@datum[:scheme]}://#{@datum[:host]}:#{@datum[:port]}#{@datum[:path]}")
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/http_clients/net_http_wrappers.rb

@@ -0,0 +1,46 @@
+# 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 HTTPClients
+      class NetHTTPRequest
+        def initialize(connection, request)
+          @connection = connection
+          @request = request
+        end
+
+        def type
+          'Net::HTTP'
+        end
+
+        def host
+          @connection.address
+        end
+
+        def method
+          @request.method
+        end
+
+        def [](key)
+          @request[key]
+        end
+
+        def []=(key, value)
+          @request[key] = value
+        end
+
+        def uri
+          case @request.path
+          when /^https?:\/\//
+            URI(@request.path)
+          else
+            scheme = @connection.use_ssl? ? 'https' : 'http'
+            URI("#{scheme}://#{@connection.address}:#{@connection.port}#{@request.path}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/http_clients/typhoeus_wrappers.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.
+
+module NewRelic
+  module Agent
+    module HTTPClients
+      class TyphoeusHTTPResponse
+        def initialize(response)
+          @response = response
+        end
+
+        def [](key)
+          unless headers.nil?
+            result = headers[key]
+
+            # Typhoeus 0.5.3 has a bug where asking the headers hash for a
+            # non-existent header will return the hash itself, not what we want.
+            result == headers ? nil : result
+          end
+        end
+
+        def to_hash
+          hash = {}
+          headers.each do |(k,v)|
+            hash[k] = v
+          end
+          hash
+        end
+
+        private
+
+        def headers
+          @response.headers
+        end
+      end
+
+      class TyphoeusHTTPRequest
+        def initialize(request)
+          @request = request
+          @uri = URI.parse(request.url)
+        end
+
+        def type
+          "Typhoeus"
+        end
+
+        def host
+          @uri.host
+        end
+
+        def method
+          (@request.options[:method] || 'GET').to_s.upcase
+        end
+
+        def [](key)
+          return nil unless @request.options && @request.options[:headers]
+          @request.options[:headers][key]
+        end
+
+        def []=(key, value)
+          @request.options[:headers] ||= {}
+          @request.options[:headers][key] = value
+        end
+
+        def uri
+          @uri
+        end
+      end
+    end
+  end
+end