newrelic_rpm 3.17.2.327 → 3.18.0.329

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

@@ -7,16 +7,24 @@ module NewRelic
     module HTTPClients
 
       class CurbRequest
+        CURB = 'Curb'.freeze
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+
         def initialize( curlobj )
           @curlobj = curlobj
         end
 
         def type
-          'Curb'
+          CURB
+        end
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
         end
 
         def host
-          self["host"] || self["Host"] || self.uri.host
+          host_from_header || self.uri.host
         end
 
         def method

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

@@ -27,6 +27,13 @@ module NewRelic
       end
 
       class ExconHTTPRequest
+        attr_reader :method
+
+        EXCON = "Excon".freeze
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+        COLON = ':'.freeze
+
         def initialize(datum)
           @datum = datum
 
@@ -34,19 +41,21 @@ module NewRelic
           @scheme = @datum[:scheme]
           @port   = @datum[:port]
           @path   = @datum[:path]
+        end
+
+        def type
+          EXCON
+        end
 
+        def host_from_header
           headers = @datum[:headers]
-          if hostname = (headers['host'] || headers['Host'])
-            @host = hostname.split(':').first
-          else
-            @host = @datum[:host]
+          if hostname = (headers[LHOST] || headers[UHOST])
+            hostname.split(COLON).first
           end
         end
 
-        attr_reader :host, :method
-
-        def type
-          "Excon"
+        def host
+          host_from_header || @datum[:host]
         end
 
         def [](key)
@@ -59,7 +68,7 @@ module NewRelic
         end
 
         def uri
-          URI.parse("#{@scheme}://#{@host}:#{@port}#{@path}")
+          URI.parse("#{@scheme}://#{host}:#{@port}#{@path}")
         end
       end
     end

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

@@ -23,6 +23,10 @@ module NewRelic
       end
 
       class HTTPRequest
+        HTTP_RB = 'http.rb'.freeze
+        HOST    = 'host'.freeze
+        COLON   = ':'.freeze
+
         attr_reader :request, :uri
 
         def initialize(request)
@@ -31,17 +35,19 @@ module NewRelic
         end
 
         def type
-          "http.rb"
+          HTTP_RB
         end
 
-        def host
-          if hostname = self['host']
-            hostname.split(':').first
-          else
-            request.host
+        def host_from_header
+          if hostname = self[HOST]
+            hostname.split(COLON).first
           end
         end
 
+        def host
+          host_from_header || request.host
+        end
+
         def method
           request.verb.upcase
         end

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

@@ -29,27 +29,34 @@ module NewRelic
       class HTTPClientRequest
         attr_reader :request, :uri
 
+        HTTP_CLIENT = "HTTPClient".freeze
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+        COLON = ':'.freeze
+
         def initialize(request)
           @request = request
           @uri = request.header.request_uri
         end
 
         def type
-          "HTTPClient"
+          HTTP_CLIENT
         end
 
         def method
           request.header.request_method
         end
 
-        def host
-          if hostname = (self['host'] || self['Host'])
-            hostname.split(':').first
-          else
-            uri.host.to_s
+        def host_from_header
+          if hostname = (self[LHOST] || self[UHOST])
+            hostname.split(COLON).first
           end
         end
 
+        def host
+          host_from_header || uri.host.to_s
+        end
+
         def [](key)
           request.headers[key]
         end

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

@@ -11,18 +11,25 @@ module NewRelic
           @request = request
         end
 
+        NET_HTTP = 'Net::HTTP'.freeze
+
         def type
-          'Net::HTTP'
+          NET_HTTP
         end
 
-        def host
-          if hostname = self['host']
-            hostname.split(':').first
-          else
-            @connection.address
+        HOST = 'host'.freeze
+        COLON = ':'.freeze
+
+        def host_from_header
+          if hostname = self[HOST]
+            hostname.split(COLON).first
           end
         end
 
+        def host
+          host_from_header || @connection.address
+        end
+
         def method
           @request.method
         end

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

@@ -44,16 +44,27 @@ module NewRelic
             end
         end
 
+        TYPHOEUS = "Typhoeus".freeze
+
         def type
-          "Typhoeus"
+          TYPHOEUS
+        end
+
+        LHOST = 'host'.freeze
+        UHOST = 'Host'.freeze
+
+        def host_from_header
+          self[LHOST] || self[UHOST]
         end
 
         def host
-          self['host'] || self['Host'] || @uri.host
+          host_from_header || @uri.host
         end
 
+        GET = 'GET'.freeze
+
         def method
-          (@request.options[:method] || 'GET').to_s.upcase
+          (@request.options[:method] || GET).to_s.upcase
         end
 
         def [](key)

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

@@ -11,27 +11,25 @@ module NewRelic
         PERFORM_ACTION = 'perform_action.action_cable'.freeze
 
         def start name, id, payload #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
           return unless state.is_execution_traced?
           event = super
           if event.name == PERFORM_ACTION
-            start_transaction state, event
+            start_transaction event
           else
-            start_recording_metrics state, event
+            start_recording_metrics event
           end
         rescue => e
           log_notification_error e, name, 'start'
         end
 
         def finish name, id, payload #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
           return unless state.is_execution_traced?
           event = super
           notice_error payload if payload.key? :exception
           if event.name == PERFORM_ACTION
-            finish_transaction state
+            finish_transaction
           else
-            stop_recording_metrics state, event
+            stop_recording_metrics event
           end
         rescue => e
           log_notification_error e, name, 'finish'
@@ -39,23 +37,20 @@ module NewRelic
 
         private
 
-        def start_transaction state, event
+        def start_transaction event
           Transaction.start(state, :action_cable, :transaction_name => transaction_name_from_event(event))
         end
 
-        def finish_transaction state
+        def finish_transaction
           Transaction.stop(state)
         end
 
-        def start_recording_metrics state, event
-          expected_scope = MethodTracerHelpers::trace_execution_scoped_header(state, event.time.to_f)
-          event.payload[:expected_scope] =  expected_scope
+        def start_recording_metrics event
+          event.payload[:segment] = Transaction.start_segment metric_name_from_event(event)
         end
 
-        def stop_recording_metrics state, event
-          expected_scope = event.payload.delete :expected_scope
-          metric_name = metric_name_from_event event
-          MethodTracerHelpers::trace_execution_scoped_footer(state, event.time.to_f, metric_name, [], expected_scope, {:metric => true}, event.end.to_f)
+        def stop_recording_metrics event
+          event.payload[:segment].finish if event.payload[:segment]
         end
 
         def transaction_name_from_event event

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

@@ -11,13 +11,12 @@ module NewRelic
       class ActionControllerSubscriber < EventedSubscriber
 
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
-          state = TransactionState.tl_get
           request = state.request
           event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
           push_event(event)
 
           if state.is_execution_traced? && !event.ignored?
-            start_transaction(state, event)
+            start_transaction(event)
           else
             # if this transaction is ignored, make sure child
             # transaction are also ignored
@@ -32,10 +31,8 @@ module NewRelic
           event = pop_event(id)
           event.payload.merge!(payload)
 
-          state = TransactionState.tl_get
-
           if state.is_execution_traced? && !event.ignored?
-            stop_transaction(state, event)
+            stop_transaction(event)
           else
             Agent.instance.pop_trace_execution_flag
           end
@@ -43,7 +40,7 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def start_transaction(state, event)
+        def start_transaction(event)
           Transaction.start(state, :controller,
                             :request          => event.request,
                             :filtered_params  => filter(event.payload[:params]),
@@ -51,7 +48,7 @@ module NewRelic
                             :transaction_name => event.metric_name)
         end
 
-        def stop_transaction(state, event)
+        def stop_transaction(event)
           txn = state.current_transaction
           txn.ignore_apdex!   if event.apdex_ignored?
           txn.ignore_enduser! if event.enduser_ignored?

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

@@ -9,15 +9,12 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionViewSubscriber < EventedSubscriber
+
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
           event = RenderEvent.new(name, Time.now, nil, id, payload)
           push_event(event)
-
-          state = NewRelic::Agent::TransactionState.tl_get
-
           if state.is_execution_traced? && event.recordable?
-            stack = state.traced_method_stack
-            event.frame = stack.push_frame(state, :action_view, event.time)
+            event.segment = NewRelic::Agent::Transaction.start_segment event.metric_name
           end
         rescue => e
           log_notification_error(e, name, 'start')
@@ -25,25 +22,13 @@ module NewRelic
 
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           event = pop_event(id)
-
-          state = NewRelic::Agent::TransactionState.tl_get
-
-          if state.is_execution_traced? && event.recordable?
-            stack = state.traced_method_stack
-            frame = stack.pop_frame(state, event.frame, event.metric_name, event.end)
-            record_metrics(event, frame)
-          end
+          event.segment.finish if event.segment
         rescue => e
           log_notification_error(e, name, 'finish')
         end
 
-        def record_metrics(event, frame) #THREAD_LOCAL_ACCESS
-          exclusive = event.duration - frame.children_time
-          NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
-            event.metric_name, nil, event.duration, exclusive)
-        end
-
         class RenderEvent < Event
+          attr_accessor :segment
 
           RENDER_TEMPLATE_EVENT_NAME   = 'render_template.action_view'.freeze
           RENDER_PARTIAL_EVENT_NAME    = 'render_partial.action_view'.freeze

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

@@ -32,7 +32,6 @@ module NewRelic
 
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           return if payload[:name] == CACHED_QUERY_NAME
-          state = NewRelic::Agent::TransactionState.tl_get
           return unless state.is_execution_traced?
           event = pop_event(id)
           event.finish

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

@@ -124,13 +124,15 @@ DependencyDetection.defer do
       # tracing if it's enabled.
       def hook_pending_request(request) #THREAD_LOCAL_ACCESS
         wrapped_request, wrapped_response = wrap_request(request)
-        state = NewRelic::Agent::TransactionState.tl_get
-        t0    = Time.now
-        node  = NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+
+        segment = NewRelic::Agent::Transaction.start_external_request_segment(
+          wrapped_request.type, wrapped_request.uri, wrapped_request.method)
+
+        segment.add_request_headers wrapped_request
 
         unless request._nr_instrumented
           install_header_callback(request, wrapped_response)
-          install_completion_callback(request, t0, node, wrapped_request, wrapped_response)
+          install_completion_callback(request, wrapped_response, segment)
           request._nr_instrumented = true
         end
       rescue => err
@@ -163,14 +165,14 @@ DependencyDetection.defer do
       end
 
       # Install a callback that will finish the trace.
-      def install_completion_callback(request, t0, node, wrapped_request, wrapped_response) #THREAD_LOCAL_ACCESS
+      def install_completion_callback(request, wrapped_response, segment) #THREAD_LOCAL_ACCESS
         original_callback = request.on_complete
         request._nr_original_on_complete = original_callback
         request.on_complete do |finished_request|
           begin
-            state = NewRelic::Agent::TransactionState.tl_get
-            NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
+            segment.read_response_headers wrapped_response
           ensure
+            segment.finish
             # 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

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

@@ -58,6 +58,10 @@ module NewRelic
         def event_stack
           Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
         end
+
+        def state
+          NewRelic::Agent::TransactionState.tl_get
+        end
       end
 
       # Taken from ActiveSupport::Notifications::Event, pasted here

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

@@ -15,14 +15,24 @@ module ::Excon
     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.tl_trace_http_request(wrapped_request) do
-        orig_response = request_without_newrelic_trace(resolved_params, &block)
-        ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(orig_response)
+      segment = NewRelic::Agent::Transaction.start_external_request_segment(
+                  wrapped_request.type, wrapped_request.uri, wrapped_request.method)
+
+      begin
+        response = nil
+        segment.add_request_headers wrapped_request
+
+        response = request_without_newrelic_trace(resolved_params, &block)
+
+        wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(response)
+        segment.read_response_headers wrapped_response
+
+        response
+      ensure
+        segment.finish
       end
-      orig_response
     end
 
     def self.install_newrelic_instrumentation