newrelic_rpm 6.13.0 → 7.1.0

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

@@ -9,7 +9,6 @@ module NewRelic
     module ActsAsSolrInstrumentation
       module ParserMethodsInstrumentation
 
-        if RUBY_VERSION < "2.7.0"
           def parse_query_with_newrelic(*args)
             self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
               begin
@@ -20,20 +19,6 @@ module NewRelic
               end
             end
           end
-  
-        else
-          def parse_query_with_newrelic(*args, **kwargs)
-            self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
-              begin
-                parse_query_without_newrelic(*args, **kwargs)
-              ensure
-                return unless txn = ::NewRelic::Agent::Tracer.current_transaction
-                txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
-              end
-            end
-          end
-  
-        end
       end
     end
   end

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

@@ -3,6 +3,10 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
+require_relative 'bunny/instrumentation'
+require_relative 'bunny/chain'
+require_relative 'bunny/prepend'
+
 DependencyDetection.defer do
   named :bunny
 
@@ -18,202 +22,12 @@ DependencyDetection.defer do
   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
+    if use_prepend?
+      prepend_instrument ::Bunny::Exchange, ::NewRelic::Agent::Instrumentation::Bunny::Prepend::Exchange
+      prepend_instrument ::Bunny::Queue, ::NewRelic::Agent::Instrumentation::Bunny::Prepend::Queue
+      prepend_instrument ::Bunny::Consumer, ::NewRelic::Agent::Instrumentation::Bunny::Prepend::Consumer
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Bunny
     end
   end
 end

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

@@ -0,0 +1,45 @@
+# 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.
+
+module NewRelic::Agent::Instrumentation
+  module Bunny
+    def self.instrument!
+      ::Bunny::Exchange.class_eval do
+        include NewRelic::Agent::Instrumentation::Bunny::Exchange
+
+        alias_method :publish_without_new_relic, :publish
+
+        def publish payload, opts = {}
+          publish_with_tracing(payload, opts) { publish_without_new_relic payload, opts }
+        end
+      end
+
+      ::Bunny::Queue.class_eval do
+        include NewRelic::Agent::Instrumentation::Bunny::Queue
+
+        alias_method :pop_without_new_relic, :pop
+
+        def pop(opts = {:manual_ack => false}, &block)
+          pop_with_tracing { pop_without_new_relic opts, &block }
+        end
+
+        alias_method :purge_without_new_relic, :purge
+
+        def purge *args
+          purge_with_tracing { purge_without_new_relic(*args) }
+        end
+      end
+
+      ::Bunny::Consumer.class_eval do
+        include NewRelic::Agent::Instrumentation::Bunny::Consumer
+
+        alias_method :call_without_new_relic, :call
+
+        def call *args
+          call_with_tracing(*args) { call_without_new_relic(*args) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# 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
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Bunny
+        module_function
+
+        LIBRARY = 'RabbitMQ'
+        DEFAULT_NAME = 'Default'
+        DEFAULT_TYPE = :direct
+        SLASH   = '/'
+
+        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
+
+        module Exchange
+          include Bunny
+
+          def publish_with_tracing payload, opts = {}
+            begin
+              destination = 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: 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
+              yield
+            else
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                yield
+              end
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
+        module Queue
+          include Bunny
+
+          def pop_with_tracing
+            bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
+            begin
+              t0 = Time.now
+              msg = yield
+              delivery_info, message_properties, _payload = msg
+            rescue StandardError => error
+              bunny_error = error
+            end
+
+            begin
+              exch_name, exch_type = if delivery_info
+                [ exchange_name(delivery_info.exchange),
+                  exchange_type(delivery_info, channel) ]
+              else
+                [ exchange_name(NewRelic::EMPTY_STR),
+                  exchange_type({}, channel) ]
+              end
+
+              segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
+                library: LIBRARY,
+                destination_name: exch_name,
+                delivery_info: (delivery_info || {}),
+                message_properties: (message_properties || {headers: {}}),
+                exchange_type: exch_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
+
+          def purge_with_tracing
+            begin
+              type = server_named? ? :temporary_queue : :queue
+              segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+                action: :purge,
+                library: LIBRARY,
+                destination_type: type,
+                destination_name: name
+              )
+            rescue => e
+              NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
+              yield
+            else
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                yield
+              end
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
+        module Consumer
+          include Bunny
+
+          def call_with_tracing *args
+            delivery_info, message_properties, _ = args
+            queue_name = queue.respond_to?(:name) ? queue.name : queue
+
+            NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
+              library: LIBRARY,
+              destination_name: exchange_name(delivery_info.exchange),
+              delivery_info: delivery_info,
+              message_properties: message_properties,
+              exchange_type: exchange_type(delivery_info, channel),
+              queue_name: queue_name) do
+
+              yield
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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.
+
+module NewRelic::Agent::Instrumentation
+  module Bunny::Prepend
+    module Exchange
+      include NewRelic::Agent::Instrumentation::Bunny::Exchange
+
+      def publish payload, opts = {}
+        publish_with_tracing(payload, opts) { super }
+      end
+    end
+
+    module Queue
+      include NewRelic::Agent::Instrumentation::Bunny::Queue
+
+      def pop(opts = {:manual_ack => false}, &block)
+        pop_with_tracing { super }
+      end
+
+      def purge *args
+        purge_with_tracing { super }
+      end
+    end
+
+    module Consumer
+      include NewRelic::Agent::Instrumentation::Bunny::Consumer
+
+      def call *args
+        call_with_tracing(*args) { super }
+      end
+    end
+  end
+end