newrelic_rpm 3.9.0.229 → 3.9.1.236

data/lib/new_relic/agent/database.rb

@@ -48,8 +48,8 @@ module NewRelic
         Obfuscator.instance.set_sql_obfuscator(type, &block)
       end
 
-      def record_sql_method
-        case Agent.config[:'transaction_tracer.record_sql'].to_s
+      def record_sql_method(config_section=:transaction_tracer)
+        case Agent.config["#{config_section}.record_sql".to_sym].to_s
         when 'off'
           :off
         when 'none'
@@ -65,12 +65,13 @@ module NewRelic
 
       RECORD_FOR = [:raw, :obfuscated].freeze
 
-      def should_record_sql?
-        RECORD_FOR.include?(record_sql_method)
+      def should_record_sql?(config_section=:transaction_tracer)
+        RECORD_FOR.include?(record_sql_method(config_section))
       end
 
-      def should_collect_explain_plans?
-        should_record_sql? && Agent.config[:'transaction_tracer.explain_enabled']
+      def should_collect_explain_plans?(config_section=:transaction_tracer)
+        should_record_sql?(config_section) &&
+          Agent.config["#{config_section}.explain_enabled".to_sym]
       end
 
       def get_connection(config, &connector)

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

@@ -16,6 +16,21 @@ module NewRelic
           end
         end
 
+        def self.insert_instrumentation
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+            include ::NewRelic::Agent::Instrumentation::ActiveRecord
+          end
+
+          ::ActiveRecord::Base.class_eval do
+            class << self
+              add_method_tracer(:find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql',
+                                :metric => false)
+              add_method_tracer(:transaction, 'ActiveRecord/#{self.name}/transaction',
+                                :metric => false)
+            end
+          end
+        end
+
         def self.included(instrumented_class)
           instrumented_class.class_eval do
             unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
@@ -89,26 +104,11 @@ DependencyDetection.defer do
 
   executes do
     if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
-      Rails.configuration.after_initialize do
-        insert_instrumentation
+      ActiveSupport.on_load(:active_record) do
+        ::NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
       end
     else
-      insert_instrumentation
-    end
-  end
-
-  def insert_instrumentation
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-      include ::NewRelic::Agent::Instrumentation::ActiveRecord
-    end
-
-    ActiveRecord::Base.class_eval do
-      class << self
-        add_method_tracer(:find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql',
-                          :metric => false)
-        add_method_tracer(:transaction, 'ActiveRecord/#{self.name}/transaction',
-                          :metric => false)
-      end
+      ::NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
     end
   end
 end

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

@@ -366,7 +366,7 @@ module NewRelic
                 perform_action_without_newrelic_trace(*args)
               end
             rescue => e
-              txn.notice_error(e)
+              NewRelic::Agent.notice_error(e)
               raise
             end
 

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

@@ -108,7 +108,7 @@ DependencyDetection.defer do
       def perform_with_newrelic(&blk)
         return perform_without_newrelic if
           self.requests.first &&
-          self.requests.first.respond_to?( :_nr_serial ) &&
+          self.requests.first.respond_to?(:_nr_serial) &&
           self.requests.first._nr_serial
 
         trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
@@ -122,24 +122,26 @@ DependencyDetection.defer do
 
       # Instrument the specified +request+ (a Curl::Easy object) and set up cross-application
       # tracing if it's enabled.
-      def hook_pending_request( request )
-        wrapped_request, wrapped_response = wrap_request( request )
-        t0, segment = NewRelic::Agent::CrossAppTracing.start_trace( wrapped_request )
+      def hook_pending_request(request) #THREAD_LOCAL_ACCESS
+        wrapped_request, wrapped_response = wrap_request(request)
+        state   = NewRelic::Agent::TransactionState.tl_get
+        t0      = Time.now
+        segment = NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
 
         unless request._nr_instrumented
-          install_header_callback( request, wrapped_response )
-          install_completion_callback( request, t0, segment, wrapped_request, wrapped_response )
+          install_header_callback(request, wrapped_response)
+          install_completion_callback(request, t0, segment, wrapped_request, wrapped_response)
           request._nr_instrumented = true
         end
       rescue => err
-        NewRelic::Agent.logger.error( "Untrapped exception", err )
+        NewRelic::Agent.logger.error("Untrapped exception", err)
       end
 
 
       # Create request and response adapter objects for the specified +request+
-      def wrap_request( request )
-        return NewRelic::Agent::HTTPClients::CurbRequest.new( request ),
-               NewRelic::Agent::HTTPClients::CurbResponse.new( request )
+      def wrap_request(request)
+        return NewRelic::Agent::HTTPClients::CurbRequest.new(request),
+               NewRelic::Agent::HTTPClients::CurbResponse.new(request)
       end
 
 
@@ -161,22 +163,23 @@ DependencyDetection.defer do
       end
 
       # Install a callback that will finish the trace.
-      def install_completion_callback( request, t0, segment, wrapped_request, wrapped_response )
+      def install_completion_callback(request, t0, segment, wrapped_request, wrapped_response) #THREAD_LOCAL_ACCESS
         original_callback = request.on_complete
         request._nr_original_on_complete = original_callback
         request.on_complete do |finished_request|
           begin
-            NewRelic::Agent::CrossAppTracing.finish_trace( t0, segment, wrapped_request, wrapped_response )
+            state = NewRelic::Agent::TransactionState.tl_get
+            NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
           ensure
             # Make sure the existing completion callback is run, and restore the
             # on_complete callback to how it was before.
-            original_callback.call( finished_request ) if original_callback
-            remove_instrumentation_callbacks( request )
+            original_callback.call(finished_request) if original_callback
+            remove_instrumentation_callbacks(request)
           end
         end
       end
 
-      def remove_instrumentation_callbacks( request )
+      def remove_instrumentation_callbacks(request)
         request.on_complete(&request._nr_original_on_complete)
         request.on_header(&request._nr_original_on_header)
         request._nr_instrumented = false

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

@@ -18,7 +18,7 @@ module ::Excon
       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
+      ::NewRelic::Agent::CrossAppTracing.tl_trace_http_request(wrapped_request) do
         orig_response = request_without_newrelic_trace(resolved_params, &block)
         ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(orig_response)
       end

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

@@ -11,7 +11,7 @@ module ::Excon
         @stack = stack
       end
 
-      def request_call(datum)
+      def request_call(datum) #THREAD_LOCAL_ACCESS
         begin
           # Only instrument this request if we haven't already done so, because
           # we can get request_call multiple times for requests marked as
@@ -19,7 +19,9 @@ module ::Excon
           # accompanying response_call/error_call.
           if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
             wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
-            t0, segment = ::NewRelic::Agent::CrossAppTracing.start_trace(wrapped_request)
+            state   = ::NewRelic::Agent::TransactionState.tl_get
+            t0      = Time.now
+            segment = ::NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
             datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, segment, wrapped_request])
           end
         rescue => e
@@ -38,7 +40,7 @@ module ::Excon
         @stack.error_call(datum)
       end
 
-      def finish_trace(datum)
+      def finish_trace(datum) #THREAD_LOCAL_ACCESS
         trace_data = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
         if trace_data
           datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
@@ -46,7 +48,8 @@ module ::Excon
           if datum[:response]
             wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
           end
-          ::NewRelic::Agent::CrossAppTracing.finish_trace(t0, segment, wrapped_request, wrapped_response)
+          state = ::NewRelic::Agent::TransactionState.tl_get
+          ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
         end
       end
     end

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

@@ -30,7 +30,7 @@ DependencyDetection.defer do
         wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(req)
 
         response = nil
-        ::NewRelic::Agent::CrossAppTracing.trace_http_request(wrapped_request) do
+        ::NewRelic::Agent::CrossAppTracing.tl_trace_http_request(wrapped_request) do
           do_get_block_without_newrelic(req, proxy, conn, &block)
           response = conn.pop
           conn.push response

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

@@ -16,8 +16,10 @@ module NewRelic
         module_function
         def instrument_methods(the_class, method_names)
           method_names.each do |method_name|
-            next unless the_class.method_defined? method_name.to_sym
+            next unless the_class.method_defined?(method_name.to_sym) || the_class.private_method_defined?(method_name.to_sym)
+            visibility = "private" unless the_class.method_defined?(method_name.to_sym)
             the_class.class_eval <<-EOD
+              #{visibility}
               def #{method_name}_with_newrelic_trace(*args, &block)
                 metrics = ["Memcache/#{method_name}",
                            (NewRelic::Agent::Transaction.recording_web_transaction? ? 'Memcache/allWeb' : 'Memcache/allOther')]
@@ -64,7 +66,12 @@ DependencyDetection.defer do
       ::NewRelic::Agent.logger.info 'Installing MemCache instrumentation'
     end
     if defined? ::Memcached
-      commands << 'cas'
+      if ::Memcached::VERSION >= '1.8.0'
+        commands -= %w[get get_multi]
+        commands += %w[single_get multi_get single_cas multi_cas]
+      else
+        commands << 'cas'
+      end
       NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Memcached,
                                                                     commands)
       ::NewRelic::Agent.logger.info 'Installing Memcached instrumentation'

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

@@ -57,7 +57,7 @@ module NewRelic
               target.call(env)
             end
           rescue => e
-            txn.notice_error(e)
+            NewRelic::Agent.notice_error(e)
             raise
           ensure
             Transaction.stop(state)

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

@@ -20,7 +20,7 @@ DependencyDetection.defer do
       def request_with_newrelic_trace(request, *args, &block)
         wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
-        NewRelic::Agent::CrossAppTracing.trace_http_request( wrapped_request ) do
+        NewRelic::Agent::CrossAppTracing.tl_trace_http_request( wrapped_request ) do
           # RUBY-1244 Disable further tracing in request to avoid double
           # counting if connection wasn't started (which calls request again).
           NewRelic::Agent.disable_all_tracing do

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -34,7 +34,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails3 Error instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 3 Error instrumentation'
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rails4/errors.rb

@@ -33,7 +33,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails4 Error instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 4 Error instrumentation'
   end
 
   executes do

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

@@ -60,13 +60,15 @@ module NewRelic::Agent::Instrumentation::TyphoeusTracing
     request.respond_to?(:hydra) && request.hydra
   end
 
-  def self.trace(request) #THREAD_LOCAL_ACCESS
-    if NewRelic::Agent.tl_is_execution_traced? && !request_is_hydra_enabled?(request)
+  def self.trace(request)
+    state = NewRelic::Agent::TransactionState.tl_get
+    if state.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)
+      t0 = Time.now
+      segment = ::NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
       callback = Proc.new do
         wrapped_response = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
-        ::NewRelic::Agent::CrossAppTracing.finish_trace(t0, segment, wrapped_request, wrapped_response)
+        ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
       end
       request.on_complete.unshift(callback)
     end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -143,11 +143,14 @@ module NewRelic
           TRANSACTION_NAME_KEY => obfuscator.obfuscate(timings.transaction_name_or_unknown),
           QUEUE_TIME_KEY       => timings.queue_time_in_millis,
           APPLICATION_TIME_KEY => timings.app_time_in_millis,
-          TT_GUID_KEY          => state.request_guid_to_include,
           AGENT_TOKEN_KEY      => state.request_token,
           AGENT_KEY            => NewRelic::Agent.config[:js_agent_file]
         }
 
+        if include_guid?(state, timings)
+          data[TT_GUID_KEY] = state.request_guid
+        end
+
         add_ssl_for_http(data)
         add_user_attributes(data, state.current_transaction)
 
@@ -169,6 +172,11 @@ module NewRelic
         data[USER_ATTRIBUTES_KEY] = obfuscator.obfuscate(json)
       end
 
+      def include_guid?(state, timings)
+        state.current_transaction &&
+          state.current_transaction.include_guid?(state, timings.app_time_in_seconds)
+      end
+
       # Still support deprecated capture_attributes.page_view_events for
       # clients that use it. Could potentially be removed if we don't have
       # anymore users with it set according to zeitgeist.

data/lib/new_relic/agent/new_relic_service.rb

@@ -491,6 +491,13 @@ module NewRelic
       class PrubyMarshaller < Marshaller
         def initialize
           ::NewRelic::Agent.logger.debug 'Using Pruby marshaller'
+          warn_for_pruby_deprecation
+        end
+
+        def warn_for_pruby_deprecation
+          if !NewRelic::LanguageSupport.stdlib_json_usable? && !defined?(::JSON)
+            NewRelic::Agent.logger.warn("Upcoming versions of the Ruby agent running on Ruby 1.8.7 will require the 'json' gem. To avoid interuption in reporting, please update your Gemfile. See http://docs.newrelic.com/docs/ruby/ruby-1.8.7-support for more information.")
+          end
         end
 
         def dump(ruby, opts={})

data/lib/new_relic/agent/obfuscator.rb

@@ -11,6 +11,7 @@ module NewRelic
       attr_reader :key_bytes
 
       EMPTY_KEY_BYTES = [0]
+      PACK_FORMAT = 'm'
 
       # RUM uses a shortened key, so just trim it up front
       def initialize(key, length=nil)
@@ -23,11 +24,11 @@ module NewRelic
       end
 
       def obfuscate(text)
-        [ encode(text) ].pack('m').chomp.gsub(/\n/, '')
+        [ encode(text) ].pack(PACK_FORMAT).gsub(/\n/, '')
       end
 
       def deobfuscate(text)
-        encode(text.unpack('m').first )
+        encode(text.unpack(PACK_FORMAT).first )
       end
 
       def encode(text)

data/lib/new_relic/agent/request_sampler.rb

@@ -22,6 +22,11 @@ class NewRelic::Agent::RequestSampler
   DURATION_KEY                   = 'duration'
   GUID_KEY                       = 'nr.guid'
   REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'
+  CAT_TRIP_ID_KEY                = 'nr.tripId'
+  CAT_PATH_HASH_KEY              = 'nr.pathHash'
+  CAT_REFERRING_PATH_HASH_KEY    = 'nr.referringPathHash'
+  CAT_ALTERNATE_PATH_HASHES_KEY  = 'nr.alternatePathHashes'
+  APDEX_PERF_ZONE_KEY            = 'nr.apdexPerfZone'
 
   def initialize( event_listener )
     super()
@@ -176,11 +181,22 @@ class NewRelic::Agent::RequestSampler
         DURATION_KEY      => float(payload[:duration]),
         TYPE_KEY          => SAMPLE_TYPE,
       })
-    optionally_append(GUID_KEY, :guid, sample, payload)
+    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)
+    optionally_append(CAT_PATH_HASH_KEY,              :cat_path_hash, sample, payload)
+    optionally_append(CAT_REFERRING_PATH_HASH_KEY,    :cat_referring_path_hash, sample, payload)
+    optionally_append(APDEX_PERF_ZONE_KEY,            :apdex_perf_zone, sample, payload)
+    append_cat_alternate_path_hashes(sample, payload)
     sample
   end
 
+  def append_cat_alternate_path_hashes(sample, payload)
+    if payload.include?(:cat_alternate_path_hashes)
+      sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(',')
+    end
+  end
+
   def optionally_append(sample_key, payload_key, sample, payload)
     if payload.include?(payload_key)
       sample[sample_key] = string(payload[payload_key])

data/lib/new_relic/agent/sql_sampler.rb

@@ -50,12 +50,13 @@ module NewRelic
 
       def enabled?
         Agent.config[:'slow_sql.enabled'] &&
-          (Agent.config[:'slow_sql.record_sql'] == 'raw' ||
-           Agent.config[:'slow_sql.record_sql'] == 'obfuscated') &&
-          Agent.config[:'transaction_tracer.enabled']
+          Agent.config[:'transaction_tracer.enabled'] &&
+          NewRelic::Agent::Database.should_record_sql?(:slow_sql)
       end
 
       def on_start_transaction(state, start_time, uri=nil)
+        return unless enabled?
+
         state.sql_sampler_transaction_data = TransactionSqlData.new
 
         if state.transaction_sample_builder
@@ -73,13 +74,15 @@ module NewRelic
 
       # This is called when we are done with the transaction.
       def on_finishing_transaction(state, name, time=Time.now)
+        return unless enabled?
+
         data = state.sql_sampler_transaction_data
-        data.set_transaction_name(name)
+        return unless data
 
+        data.set_transaction_name(name)
         if data.sql_data.size > 0
           @samples_lock.synchronize do
             ::NewRelic::Agent.logger.debug "Harvesting #{data.sql_data.size} slow transaction sql statement(s)"
-            #FIXME get tx name and uri
             harvest_slow_sql data
           end
         end
@@ -145,7 +148,8 @@ module NewRelic
       end
 
       def harvest!
-        return [] if !Agent.config[:'slow_sql.enabled']
+        return [] unless enabled?
+
         result = []
         @samples_lock.synchronize do
           result = @sql_traces.values