newrelic_rpm 6.15.0 → 9.7.1

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

@@ -0,0 +1,159 @@
+# 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 = '/'
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+        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 = {})
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+            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
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
+            end
+          end
+        end
+
+        module Queue
+          include Bunny
+
+          def pop_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+            bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
+            begin
+              t0 = Process.clock_gettime(Process::CLOCK_REALTIME)
+              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
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
+            end
+
+            msg
+          end
+
+          def purge_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+            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
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
+            end
+          end
+        end
+
+        module Consumer
+          include Bunny
+
+          def call_with_tracing(*args)
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+            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 @@
+# 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::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

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

@@ -1,8 +1,11 @@
-# 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
 
+require_relative 'bunny/instrumentation'
+require_relative 'bunny/chain'
+require_relative 'bunny/prepend'
+
 DependencyDetection.defer do
   named :bunny
 
@@ -11,165 +14,19 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Bunny instrumentation'
+    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
-
-        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
-
-      end
-
-      class Consumer
-        alias_method :call_without_new_relic, :call
-
-        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
-
-      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::Chain
     end
   end
 end

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

@@ -0,0 +1,36 @@
+# 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::Agent::Instrumentation
+  module ConcurrentRuby::Chain
+    def self.instrument!
+      ::Concurrent::ThreadPoolExecutor.class_eval do
+        include NewRelic::Agent::Instrumentation::ConcurrentRuby
+
+        alias_method(:post_without_new_relic, :post)
+
+        def post(*args, &task)
+          return post_without_new_relic(*args, &task) unless NewRelic::Agent::Tracer.tracing_enabled?
+
+          traced_task = add_task_tracing(&task)
+          post_without_new_relic(*args, &traced_task)
+        end
+      end
+
+      [::Concurrent::Promises.const_get(:'InternalStates')::Rejected,
+        ::Concurrent::Promises.const_get(:'InternalStates')::PartiallyRejected].each do |klass|
+        klass.class_eval do
+          alias_method(:initialize_without_new_relic, :initialize)
+
+          # Uses args.last to record the error becuase the methods that this will monkey patch
+          # look like: initialize(reason) & initialize(value, reason)
+          def initialize(*args)
+            NewRelic::Agent.notice_error(args.last) if args.last.is_a?(Exception)
+            initialize_without_new_relic(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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::Agent::Instrumentation
+  module ConcurrentRuby
+    SEGMENT_NAME = 'Concurrent/Task'
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+    def add_task_tracing(&task)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      NewRelic::Agent::Tracer.thread_block_with_current_transaction(
+        segment_name: SEGMENT_NAME,
+        parent: NewRelic::Agent::Tracer.current_segment,
+        &task
+      )
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# 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::Agent::Instrumentation
+  module ConcurrentRuby
+    module Prepend
+      include NewRelic::Agent::Instrumentation::ConcurrentRuby
+
+      def post(*args, &task)
+        return super(*args, &task) unless NewRelic::Agent::Tracer.tracing_enabled?
+
+        traced_task = add_task_tracing(&task)
+        super(*args, &traced_task)
+      end
+    end
+
+    module ErrorPrepend
+      # Uses args.last to record the error because the methods that this will be prepended to
+      # look like: initialize(reason) & initialize(value, reason)
+      def initialize(*args)
+        NewRelic::Agent.notice_error(args.last) if args.last.is_a?(Exception)
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# 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
+
+require_relative 'concurrent_ruby/instrumentation'
+require_relative 'concurrent_ruby/chain'
+require_relative 'concurrent_ruby/prepend'
+
+DependencyDetection.defer do
+  named :'concurrent_ruby'
+
+  depends_on do
+    defined?(Concurrent) &&
+      Gem::Version.new(Concurrent::VERSION) >= Gem::Version.new('1.1.5')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing concurrent-ruby instrumentation')
+
+    if use_prepend?
+      prepend_instrument(Concurrent::ThreadPoolExecutor, NewRelic::Agent::Instrumentation::ConcurrentRuby::Prepend)
+
+      [Concurrent::Promises.const_get(:'InternalStates')::Rejected,
+        Concurrent::Promises.const_get(:'InternalStates')::PartiallyRejected].each do |klass|
+          klass.prepend(NewRelic::Agent::Instrumentation::ConcurrentRuby::ErrorPrepend)
+        end
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::ConcurrentRuby::Chain
+    end
+  end
+end