newrelic_rpm 4.0.0.332 → 6.13.1

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

@@ -0,0 +1,219 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+DependencyDetection.defer do
+  named :bunny
+
+  depends_on do
+    defined?(Bunny)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Bunny instrumentation'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
+    require 'new_relic/agent/messaging'
+    require 'new_relic/agent/transaction/message_broker_segment'
+  end
+
+  executes do
+    module Bunny
+      class Exchange
+        alias_method :publish_without_new_relic, :publish
+
+        def publish payload, opts = {}
+          begin
+            destination = NewRelic::Agent::Instrumentation::Bunny.exchange_name(name)
+
+            tracing_enabled =
+              NewRelic::Agent::CrossAppTracing.cross_app_enabled? ||
+              NewRelic::Agent.config[:'distributed_tracing.enabled']
+            opts[:headers] ||= {} if tracing_enabled
+
+            segment = NewRelic::Agent::Messaging.start_amqp_publish_segment(
+              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+              destination_name: destination,
+              headers: opts[:headers],
+              routing_key: opts[:routing_key] || opts[:key],
+              reply_to: opts[:reply_to],
+              correlation_id: opts[:correlation_id],
+              exchange_type: type
+            )
+          rescue => e
+            NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Exchange#publish", e
+            publish_without_new_relic payload, opts
+          else
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              publish_without_new_relic payload, opts
+            end
+          ensure
+            segment.finish if segment
+          end
+        end
+      end
+
+      class Queue
+        alias_method :pop_without_new_relic, :pop
+
+        def pop(opts = {:manual_ack => false}, &block)
+          bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
+          begin
+            t0 = Time.now
+            msg = pop_without_new_relic opts, &block
+            delivery_info, message_properties, _payload = msg
+          rescue StandardError => error
+            bunny_error = error
+          end
+
+          begin
+            exchange_name, exchange_type = if delivery_info
+              [ NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
+                NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel) ]
+            else
+              [ NewRelic::Agent::Instrumentation::Bunny.exchange_name(NewRelic::EMPTY_STR),
+                NewRelic::Agent::Instrumentation::Bunny.exchange_type({}, channel) ]
+            end
+
+            segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
+              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+              destination_name: exchange_name,
+              delivery_info: (delivery_info || {}),
+              message_properties: (message_properties || {headers: {}}),
+              exchange_type: exchange_type,
+              queue_name: name,
+              start_time: t0
+            )
+          rescue => e
+            NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#pop", e
+          else
+            if bunny_error
+              segment.notice_error bunny_error
+              raise bunny_error
+            end
+          ensure
+            segment.finish if segment
+          end
+
+          msg
+        end
+
+        alias_method :purge_without_new_relic, :purge
+
+        if RUBY_VERSION < "2.7.0"
+          def purge *args
+            begin
+              type = server_named? ? :temporary_queue : :queue
+              segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+                action: :purge,
+                library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+                destination_type: type,
+                destination_name: name
+              )
+            rescue => e
+              NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
+              purge_without_new_relic(*args)
+            else
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                purge_without_new_relic(*args)
+              end
+            ensure
+              segment.finish if segment
+            end
+          end
+
+        else     
+          def purge *args, **kwargs
+            begin
+              type = server_named? ? :temporary_queue : :queue
+              segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+                action: :purge,
+                library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+                destination_type: type,
+                destination_name: name
+              )
+            rescue => e
+              NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
+              purge_without_new_relic(*args, **kwargs)
+            else
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                purge_without_new_relic(*args, **kwargs)
+              end
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
+      end
+
+      class Consumer
+        alias_method :call_without_new_relic, :call
+
+        if RUBY_VERSION < "2.7.0"
+          def call *args
+            delivery_info, message_properties, _ = args
+            queue_name = queue.respond_to?(:name) ? queue.name : queue
+  
+            NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
+              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+              destination_name: NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
+              delivery_info: delivery_info,
+              message_properties: message_properties,
+              exchange_type: NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel),
+              queue_name: queue_name) do
+  
+              call_without_new_relic(*args)
+            end
+          end
+        else
+          def call *args, **kwargs
+            delivery_info, message_properties, _ = args
+            queue_name = queue.respond_to?(:name) ? queue.name : queue
+
+            NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
+              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+              destination_name: NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
+              delivery_info: delivery_info,
+              message_properties: message_properties,
+              exchange_type: NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel),
+              queue_name: queue_name) do
+
+              call_without_new_relic(*args, **kwargs)
+            end
+          end
+        end
+
+
+
+      end
+    end
+  end
+end
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Bunny
+        LIBRARY = 'RabbitMQ'
+        DEFAULT_NAME = 'Default'
+        DEFAULT_TYPE = :direct
+
+        SLASH   = '/'
+
+        class << self
+          def exchange_name name
+            name.empty? ? DEFAULT_NAME : name
+          end
+
+          def exchange_type delivery_info, channel
+            if di_exchange = delivery_info[:exchange]
+              return DEFAULT_TYPE if di_exchange.empty?
+              return channel.exchanges[delivery_info[:exchange]].type if channel.exchanges[di_exchange]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/instrumentation/queue_time'
@@ -55,6 +55,7 @@ module NewRelic
           # @api public
           #
           def newrelic_ignore(specifiers={})
+            NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore)
             newrelic_ignore_aspect(NR_DO_NOT_TRACE_KEY, specifiers)
           end
           # Have NewRelic omit apdex measurements on the given actions.  Typically used for
@@ -64,11 +65,13 @@ module NewRelic
           # @api public
           #
           def newrelic_ignore_apdex(specifiers={})
+            NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore_apdex)
             newrelic_ignore_aspect(NR_IGNORE_APDEX_KEY, specifiers)
           end
 
           # @api public
           def newrelic_ignore_enduser(specifiers={})
+            NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore_enduser)
             newrelic_ignore_aspect(NR_IGNORE_ENDUSER_KEY, specifiers)
           end
 
@@ -156,6 +159,8 @@ module NewRelic
           # @api public
           #
           def add_transaction_tracer(method, options={})
+            NewRelic::Agent.record_api_supportability_metric(:add_transaction_tracer)
+
             # The metric path:
             options[:name] ||= method.to_s
 
@@ -228,7 +233,9 @@ module NewRelic
             category ||= (txn && txn.category)
             case category
             when :controller    then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :web           then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
             when :task          then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :background    then ::NewRelic::Agent::Transaction::TASK_PREFIX
             when :rack          then ::NewRelic::Agent::Transaction::RACK_PREFIX
             when :uri           then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
             when :sinatra       then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
@@ -236,6 +243,7 @@ module NewRelic
             when :grape         then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
             when :rake          then ::NewRelic::Agent::Transaction::RAKE_PREFIX
             when :action_cable  then ::NewRelic::Agent::Transaction::ACTION_CABLE_PREFIX
+            when :message       then ::NewRelic::Agent::Transaction::MESSAGE_PREFIX
             else "#{category.to_s}/" # for internal use only
             end
           end
@@ -337,8 +345,10 @@ module NewRelic
         # @api public
         #
         def perform_action_with_newrelic_trace(*args, &block) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
-          state.request = newrelic_request(args)
+          NewRelic::Agent.record_api_supportability_metric(:perform_action_with_newrelic_trace)
+          state = NewRelic::Agent::Tracer.state
+          request = newrelic_request(args)
+          queue_start_time = detect_queue_start_time(request)
 
           skip_tracing = do_not_trace? || !state.is_execution_traced?
 
@@ -353,10 +363,14 @@ module NewRelic
 
           trace_options = args.last.is_a?(Hash) ? args.last : NR_DEFAULT_OPTIONS
           category      = trace_options[:category] || :controller
-          txn_options   = create_transaction_options(trace_options, category, state)
+          txn_options   = create_transaction_options(trace_options, category, state, queue_start_time)
 
           begin
-            txn = Transaction.start(state, category, txn_options)
+            finishable = Tracer.start_transaction_or_segment(
+              name: txn_options[:transaction_name],
+              category: category,
+              options: txn_options
+            )
 
             begin
               yield
@@ -366,11 +380,7 @@ module NewRelic
             end
 
           ensure
-            if txn
-              txn.ignore_apdex!   if ignore_apdex?
-              txn.ignore_enduser! if ignore_enduser?
-            end
-            Transaction.stop(state)
+            finishable.finish if finishable
           end
         end
 
@@ -390,8 +400,7 @@ module NewRelic
         # Should be implemented in the dispatcher class
         def newrelic_response_code; end
 
-        def newrelic_request_headers(state)
-          request = state.request
+        def newrelic_request_headers(request)
           if request
             if request.respond_to?(:headers)
               request.headers
@@ -422,14 +431,16 @@ module NewRelic
 
         private
 
-        def create_transaction_options(trace_options, category, state)
+        def create_transaction_options(trace_options, category, state, queue_start_time)
           txn_options = {}
           txn_options[:request]   = trace_options[:request]
           txn_options[:request] ||= request if respond_to?(:request) rescue nil
           # params should have been filtered before calling perform_action_with_newrelic_trace
           txn_options[:filtered_params] = trace_options[:params]
           txn_options[:transaction_name] = TransactionNamer.name_for(nil, self, category, trace_options)
-          txn_options[:apdex_start_time] = detect_queue_start_time(state)
+          txn_options[:apdex_start_time] = queue_start_time
+          txn_options[:ignore_apdex] = ignore_apdex?
+          txn_options[:ignore_enduser] = ignore_enduser?
           txn_options
         end
 
@@ -448,8 +459,8 @@ module NewRelic
             name)
         end
 
-        def detect_queue_start_time(state)
-          headers = newrelic_request_headers(state)
+        def detect_queue_start_time(request)
+          headers = newrelic_request_headers(request)
 
           QueueTime.parse_frontend_timestamp(headers) if headers
         end

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 DependencyDetection.defer do
   named :curb
@@ -14,7 +14,7 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Curb instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/curb_wrappers'
   end
 
@@ -22,38 +22,64 @@ DependencyDetection.defer do
     class Curl::Easy
 
       attr_accessor :_nr_instrumented,
+                    :_nr_failure_instrumented,
                     :_nr_http_verb,
                     :_nr_header_str,
                     :_nr_original_on_header,
                     :_nr_original_on_complete,
+                    :_nr_original_on_failure,
                     :_nr_serial
 
       # We have to hook these three methods separately, as they don't use
       # Curl::Easy#http
-      def http_head_with_newrelic(*args, &blk)
-        self._nr_http_verb = :HEAD
-        http_head_without_newrelic(*args, &blk)
+      if RUBY_VERSION < "2.7.0"
+        def http_head_with_newrelic(*args, &blk)
+          self._nr_http_verb = :HEAD
+          http_head_without_newrelic(*args, &blk)
+        end
+      else
+        def http_head_with_newrelic(*args, **kwargs, &blk)
+          self._nr_http_verb = :HEAD
+          http_head_without_newrelic(*args, **kwargs, &blk)
+        end
       end
+
       alias_method :http_head_without_newrelic, :http_head
       alias_method :http_head, :http_head_with_newrelic
 
-      def http_post_with_newrelic(*args, &blk)
-        self._nr_http_verb = :POST
-        http_post_without_newrelic(*args, &blk)
+      if RUBY_VERSION < "2.7.0"
+        def http_post_with_newrelic(*args, &blk)
+          self._nr_http_verb = :POST
+          http_post_without_newrelic(*args, &blk)
+        end
+      else
+        def http_post_with_newrelic(*args, **kwargs, &blk)
+          self._nr_http_verb = :POST
+          http_post_without_newrelic(*args, **kwargs, &blk)
+        end
       end
+
       alias_method :http_post_without_newrelic, :http_post
       alias_method :http_post, :http_post_with_newrelic
 
-      def http_put_with_newrelic(*args, &blk)
-        self._nr_http_verb = :PUT
-        http_put_without_newrelic(*args, &blk)
+      if RUBY_VERSION < "2.7.0"
+        def http_put_with_newrelic(*args, &blk)
+          self._nr_http_verb = :PUT
+          http_put_without_newrelic(*args, &blk)
+        end
+      else
+        def http_put_with_newrelic(*args, **kwargs, &blk)
+          self._nr_http_verb = :PUT
+          http_put_without_newrelic(*args, **kwargs, &blk)
+        end
       end
+
       alias_method :http_put_without_newrelic, :http_put
       alias_method :http_put, :http_put_with_newrelic
 
 
       # Hook the #http method to set the verb.
-      def http_with_newrelic( verb )
+      def http_with_newrelic verb
         self._nr_http_verb = verb.to_s.upcase
         http_without_newrelic( verb )
       end
@@ -61,9 +87,9 @@ DependencyDetection.defer do
       alias_method :http_without_newrelic, :http
       alias_method :http, :http_with_newrelic
 
-
       # Hook the #perform method to mark the request as non-parallel.
       def perform_with_newrelic
+        self._nr_http_verb ||= :GET
         self._nr_serial = true
         perform_without_newrelic
       end
@@ -71,6 +97,15 @@ DependencyDetection.defer do
       alias_method :perform_without_newrelic, :perform
       alias_method :perform, :perform_with_newrelic
 
+      # Record the HTTP verb for future #perform calls
+      def method_with_newrelic verb
+        self._nr_http_verb = verb.upcase
+        method_without_newrelic(verb)
+      end
+
+      alias_method :method_without_newrelic, :method
+      alias_method :method, :method_with_newrelic
+
       # We override this method in order to ensure access to header_str even
       # though we use an on_header callback
       def header_str_with_newrelic
@@ -92,24 +127,20 @@ DependencyDetection.defer do
       include NewRelic::Agent::MethodTracer
 
       # Add CAT with callbacks if the request is serial
-      def add_with_newrelic(curl) #THREAD_LOCAL_ACCESS
+      def add_with_newrelic(curl)
         if curl.respond_to?(:_nr_serial) && curl._nr_serial
-          hook_pending_request(curl) if NewRelic::Agent.tl_is_execution_traced?
+          hook_pending_request(curl) if NewRelic::Agent::Tracer.tracing_enabled?
         end
 
-        return add_without_newrelic( curl )
+        return add_without_newrelic curl
       end
 
       alias_method :add_without_newrelic, :add
       alias_method :add, :add_with_newrelic
 
-
       # Trace as an External/Multiple call if the first request isn't serial.
       def perform_with_newrelic(&blk)
-        return perform_without_newrelic if
-          self.requests.first &&
-          self.requests.first.respond_to?(:_nr_serial) &&
-          self.requests.first._nr_serial
+        return perform_without_newrelic if first_request_is_serial?
 
         trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
           perform_without_newrelic(&blk)
@@ -120,19 +151,24 @@ DependencyDetection.defer do
       alias_method :perform, :perform_with_newrelic
 
 
-      # Instrument the specified +request+ (a Curl::Easy object) and set up cross-application
-      # tracing if it's enabled.
-      def hook_pending_request(request) #THREAD_LOCAL_ACCESS
+      # 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)
 
-        segment = NewRelic::Agent::Transaction.start_external_request_segment(
-          wrapped_request.type, wrapped_request.uri, wrapped_request.method)
+        segment = NewRelic::Agent::Tracer.start_external_request_segment(
+          library: wrapped_request.type,
+          uri: wrapped_request.uri,
+          procedure: wrapped_request.method
+        )
 
         segment.add_request_headers wrapped_request
 
+        # install all callbacks
         unless request._nr_instrumented
           install_header_callback(request, wrapped_response)
           install_completion_callback(request, wrapped_response, segment)
+          install_failure_callback(request, wrapped_response, segment)
           request._nr_instrumented = true
         end
       rescue => err
@@ -141,38 +177,39 @@ DependencyDetection.defer do
 
 
       # Create request and response adapter objects for the specified +request+
+      # NOTE: Although strange to wrap request and response at once, it works
+      # because curb's callback mechanism updates the instantiated wrappers
+      # during the life-cycle of external request
       def wrap_request(request)
         return NewRelic::Agent::HTTPClients::CurbRequest.new(request),
                NewRelic::Agent::HTTPClients::CurbResponse.new(request)
       end
 
-
-      # Install a callback that will record the response headers to enable
-      # CAT linking
-      def install_header_callback( request, wrapped_response )
+      # Install a callback that will record the response headers
+      # to enable CAT linking
+      def install_header_callback(request, wrapped_response)
         original_callback = request.on_header
         request._nr_original_on_header = original_callback
-        request._nr_header_str = ''
+        request._nr_header_str = nil
         request.on_header do |header_data|
-          wrapped_response.append_header_data( header_data )
-
           if original_callback
-            original_callback.call( header_data )
+            original_callback.call header_data
           else
+            wrapped_response.append_header_data header_data
             header_data.length
           end
         end
       end
 
       # Install a callback that will finish the trace.
-      def install_completion_callback(request, wrapped_response, segment) #THREAD_LOCAL_ACCESS
+      def install_completion_callback(request, wrapped_response, segment)
         original_callback = request.on_complete
         request._nr_original_on_complete = original_callback
         request.on_complete do |finished_request|
           begin
-            segment.read_response_headers wrapped_response
+            segment.process_response_headers wrapped_response
           ensure
-            segment.finish
+            segment.finish if segment
             # 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
@@ -181,12 +218,64 @@ DependencyDetection.defer do
         end
       end
 
+      # Install a callback that will fire on failures
+      # NOTE:  on_failure is not always called, so we're not always
+      # unhooking the callback.  No harm/no foul in production, but
+      # definitely something to beware of if debugging callback issues
+      # _nr_failure_instrumented exists to prevent infinitely chaining
+      # our on_failure callback hook.
+      def install_failure_callback(request, wrapped_response, segment)
+        return if request._nr_failure_instrumented
+        original_callback = request.on_failure
+        request._nr_original_on_failure = original_callback
+        request.on_failure do |failed_request, error|
+          begin
+            if segment
+              noticible_error = NewRelic::Agent::NoticibleError.new error[0].name, error[-1]
+              segment.notice_error noticible_error
+            end
+          ensure
+            original_callback.call(failed_request, error) if original_callback
+            remove_failure_callback(failed_request)
+          end
+          request._nr_failure_instrumented = true 
+        end
+      end
+
+      # on_failure callbacks cannot be removed in the on_complete
+      # callback where this method is invoked because on_complete
+      # fires before the on_failure!
       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
       end
 
+      # We execute customer's on_failure callback (if any) and 
+      # uninstall our hook here since the on_complete callback 
+      # fires before the on_failure callback.
+      def remove_failure_callback(request)
+        request.on_failure(&request._nr_original_on_failure)
+        request._nr_failure_instrumented = false
+      end
+
+      private
+
+      def first_request_is_serial?
+        return false unless (first = self.requests.first)
+
+        # Before curb 0.9.8, requests was an array of Curl::Easy
+        # instances.  Starting with 0.9.8, it's a Hash where the
+        # values are Curl::Easy instances.
+        #
+        # So, requests.first will either be an_obj or [a_key, an_obj].
+        # We need to handle either case.
+        #
+        first = first[-1] if first.is_a?(Array)
+
+        first.respond_to?(:_nr_serial) && first._nr_serial
+      end
+
     end # class Curl::Multi
 
   end