newrelic_rpm 3.17.2.327 → 3.18.0.329

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

@@ -19,10 +19,12 @@ 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)
-            state   = ::NewRelic::Agent::TransactionState.tl_get
-            t0      = Time.now
-            node = ::NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
-            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, node, 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
+
+            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, segment)
           end
         rescue => e
           NewRelic::Agent.logger.debug(e)
@@ -41,15 +43,18 @@ module ::Excon
       end
 
       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)
-          t0, node, wrapped_request = trace_data
-          if datum[:response]
-            wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
+        segment = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+        if segment
+          begin
+            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
+
+            if datum[:response]
+              wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
+              segment.read_response_headers wrapped_response
+            end
+          ensure
+            segment.finish
           end
-          state = ::NewRelic::Agent::TransactionState.tl_get
-          ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
         end
       end
     end

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

@@ -20,13 +20,20 @@ DependencyDetection.defer do
       def perform_with_newrelic_trace(request, options)
         wrapped_request = ::NewRelic::Agent::HTTPClients::HTTPRequest.new(request)
 
-        response = nil
-        ::NewRelic::Agent::CrossAppTracing.tl_trace_http_request(wrapped_request) do
+        begin
+          segment = NewRelic::Agent::Transaction.start_external_request_segment(
+            wrapped_request.type, wrapped_request.uri, wrapped_request.method)
+
+          segment.add_request_headers wrapped_request
+
           response = perform_without_newrelic_trace(request, options)
-          ::NewRelic::Agent::HTTPClients::HTTPResponse.new(response)
-        end
+          wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPResponse.new response
+          segment.read_response_headers wrapped_response
 
-        response
+          response
+        ensure
+          segment.finish if segment
+        end
       end
 
       alias perform_without_newrelic_trace perform

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

@@ -28,15 +28,24 @@ DependencyDetection.defer do
     class HTTPClient
       def do_get_block_with_newrelic(req, proxy, conn, &block)
         wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(req)
+        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 = nil
-        ::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
-          ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
+
+          wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
+          segment.read_response_headers wrapped_response
+
+          response
+        ensure
+          segment.finish
         end
-        response
       end
 
       alias do_get_block_without_newrelic do_get_block

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

@@ -20,12 +20,23 @@ DependencyDetection.defer do
       def request_with_newrelic_trace(request, *args, &block)
         wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
-        NewRelic::Agent::CrossAppTracing.tl_trace_http_request( wrapped_request ) do
+        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
+
           # 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
-            request_without_newrelic_trace( request, *args, &block )
+            response = request_without_newrelic_trace( request, *args, &block )
           end
+
+          segment.read_response_headers response
+          response
+        ensure
+          segment.finish
         end
       end
 

data/lib/new_relic/agent/instrumentation/rails5/action_controller.rb

@@ -20,16 +20,8 @@ DependencyDetection.defer do
   end
 
   executes do
-    if defined?(ActionController::Base)
-      class ActionController::Base
-        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      end
-    end
-
-    if defined?(ActionController::API)
-      class ActionController::API
-        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      end
+    ActiveSupport.on_load(:action_controller) do |c|
+      c.include NewRelic::Agent::Instrumentation::ControllerInstrumentation
     end
 
     NewRelic::Agent::Instrumentation::ActionControllerSubscriber \

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

@@ -64,11 +64,16 @@ module NewRelic::Agent::Instrumentation::TyphoeusTracing
     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 = 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
+
       callback = Proc.new do
         wrapped_response = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
-        ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
+        segment.read_response_headers wrapped_response
+        segment.finish
       end
       request.on_complete.unshift(callback)
     end

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -75,7 +75,9 @@ module NewRelic
         return yield unless first_name
 
         segment = NewRelic::Agent::Transaction.start_segment first_name, metric_names
-        segment.record_metrics = options.fetch(:metric, true)
+        if options[:metric] == false
+          segment.record_metrics = false
+        end
 
         begin
           yield

data/lib/new_relic/agent/parameter_filtering.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-# This file is distributed under New Relic"s license terms.
+# This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 module NewRelic

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

@@ -66,15 +66,6 @@ module NewRelic
           end
         end
 
-        # This aliasing was introduced for T2 so that MetricsStats and
-        # TransactionStates have the same interface for recording
-        # unscoped metrics. The tl_ version should be used outside of the
-        # segment api.
-        #
-        # @api private
-        #
-        alias_method :record_unscoped, :tl_record_unscoped_metrics
-
         # Like tl_record_unscoped_metrics, but records a scoped metric as well.
         #
         # This is an internal method, subject to change at any time. Client apps
@@ -117,15 +108,6 @@ module NewRelic
           end
         end
 
-        # This aliasing was introduced for T2 so that MetricsStats and
-        # TransactionStates have the same interface for recording
-        # scoped metrics. The tl_ version should be used outside of the
-        # segment api.
-        #
-        # @api private
-        #
-        alias_method :record_scoped_and_unscoped, :tl_record_scoped_and_unscoped_metrics
-
         # This method is deprecated and not thread safe, and should not be used
         # by any new client code.
         #

data/lib/new_relic/agent/supported_versions.rb

@@ -12,6 +12,7 @@ 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", "~> 2.3.0"],
+        :experimental=> ["2.4.0-preview3"],
         :url         => "https://www.ruby-lang.org",
         :feed        => "https://www.ruby-lang.org/en/feeds/news.rss",
         :notes       => [

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

@@ -9,7 +9,7 @@ module NewRelic
         attr_reader :start_time, :end_time, :duration, :exclusive_duration
         attr_accessor :name, :children_time, :transaction
 
-        def initialize name
+        def initialize name=nil
           @name = name
           @children_time = 0.0
           @record_metrics = true
@@ -24,9 +24,11 @@ module NewRelic
           @end_time = Time.now
           @duration = end_time.to_f - start_time.to_f
           @exclusive_duration = duration - children_time
-          record_metrics if record_metrics?
-          segment_complete
-          @transaction.segment_complete self if transaction
+          if transaction
+            record_metrics if record_metrics?
+            segment_complete
+            transaction.segment_complete self
+          end
         rescue => e
           # This rescue block was added for the benefit of this test:
           # test/multiverse/suites/bare/standalone_instrumentation_test.rb
@@ -62,11 +64,7 @@ module NewRelic
         end
 
         def metric_cache
-          if transaction
-            transaction.metrics
-          else
-            NewRelic::Agent.instance.stats_engine
-          end
+          transaction.metrics
         end
 
         def transaction_state

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

@@ -0,0 +1,139 @@
+# 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/transaction/segment'
+require 'new_relic/agent/http_clients/uri_util'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class ExternalRequestSegment < Segment
+        attr_reader :library, :uri, :procedure
+
+        def initialize library, uri, procedure
+          @library = library
+          @uri = normalize_uri uri
+          @procedure = procedure
+          @host_header = nil
+          @app_data = nil
+          super()
+        end
+
+        def name
+          @name ||= "External/#{host}/#{library}/#{procedure}"
+        end
+
+        def host
+          @host_header || uri.host
+        end
+
+        # This method will add NewRelic headers for cross application tracing and
+        # will check to see if a host header is used for the request. If a host
+        # header is used it will update the segment name to reflect the host header.
+        def add_request_headers request
+          process_host_header request
+          return unless record_metrics? && CrossAppTracing.cross_app_enabled?
+
+          transaction_state.is_cross_app_caller = true
+          txn_guid = transaction_state.request_guid
+          trip_id   = transaction && transaction.cat_trip_id(transaction_state)
+          path_hash = transaction && transaction.cat_path_hash(transaction_state)
+          synthetics_header = transaction && transaction.raw_synthetics_header
+
+          CrossAppTracing.insert_request_headers request, txn_guid, trip_id, path_hash, synthetics_header
+        rescue => e
+          NewRelic::Agent.logger.error "Error in add_request_headers", e
+        end
+
+        def read_response_headers response
+          return unless record_metrics? && CrossAppTracing.cross_app_enabled?
+          return unless CrossAppTracing.response_has_crossapp_header?(response)
+          unless data = CrossAppTracing.extract_appdata(response)
+            NewRelic::Agent.logger.debug "Couldn't extract_appdata from external segment response"
+            return
+          end
+
+          if CrossAppTracing.valid_cross_app_id?(data[0])
+            @app_data = data
+            update_segment_name
+          else
+            NewRelic::Agent.logger.debug "External segment response has invalid cross_app_id"
+          end
+        rescue => e
+          NewRelic::Agent.logger.error "Error in read_response_headers", e
+        end
+
+        def cross_app_request?
+          !!@app_data
+        end
+
+        def cross_process_id
+          @app_data && @app_data[0]
+        end
+
+        def transaction_guid
+          @app_data && @app_data[5]
+        end
+
+        def cross_process_transaction_name
+          @app_data && @app_data[1]
+        end
+
+        private
+
+        def segment_complete
+          node_params = {:uri => HTTPClients::URIUtil.filter_uri(uri)}
+          if cross_app_request?
+            node_params[:transaction_guid] = transaction_guid
+          end
+          Agent.instance.transaction_sampler.add_node_parameters node_params
+        end
+
+        def normalize_uri uri
+          uri.is_a?(URI) ? uri : HTTPClients::URIUtil.parse_url(uri)
+        end
+
+        def process_host_header request
+          if @host_header = request.host_from_header
+            update_segment_name
+          end
+        end
+
+        EXTERNAL_ALL = "External/all".freeze
+
+        def unscoped_metrics
+          metrics = [ EXTERNAL_ALL,
+            "External/#{host}/all",
+            suffixed_rollup_metric
+          ]
+
+          if cross_app_request?
+            metrics << "ExternalApp/#{host}/#{cross_process_id}/all"
+          end
+
+          metrics
+        end
+
+        EXTERNAL_ALL_WEB = "External/allWeb".freeze
+        EXTERNAL_ALL_OTHER = "External/allOther".freeze
+
+        def suffixed_rollup_metric
+          if Transaction.recording_web_transaction?
+            EXTERNAL_ALL_WEB
+          else
+            EXTERNAL_ALL_OTHER
+          end
+        end
+
+        def update_segment_name
+          if @app_data
+            @name = "ExternalTransaction/#{host}/#{cross_process_id}/#{cross_process_transaction_name}"
+          else
+            @name = "External/#{host}/#{library}/#{procedure}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module NewRelic
         # initialize it as an array that would be empty, have one item, or many items.
         attr_reader :unscoped_metrics
 
-        def initialize name, unscoped_metrics=nil
+        def initialize name = nil, unscoped_metrics=nil
           @unscoped_metrics = unscoped_metrics
           super name
         end

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

@@ -4,6 +4,7 @@
 
 require 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/transaction/datastore_segment'
+require 'new_relic/agent/transaction/external_request_segment'
 
 module NewRelic
   module Agent
@@ -29,13 +30,21 @@ module NewRelic
             segment
           end
 
+          def start_external_request_segment library, uri, procedure
+            segment = ExternalRequestSegment.new library, uri, procedure
+            segment.start
+            add_segment segment
+            segment
+          end
+
           private
 
           def add_segment segment
             state = NewRelic::Agent::TransactionState.tl_get
-            segment.record_metrics = state.is_execution_traced?
             if (txn = state.current_transaction) && state.is_execution_traced?
               txn.add_segment segment
+            else
+              segment.record_metrics = false
             end
           end
         end