newrelic_rpm 6.15.0 → 7.0.0

data/lib/new_relic/agent/configuration/manager.rb

@@ -23,7 +23,7 @@ module NewRelic
         end
 
         def has_key?(key)
-          @cache.has_key?[key]
+          @cache.has_key? key
         end
 
         def keys
@@ -345,7 +345,7 @@ module NewRelic
         end
 
         def reset_cache
-          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+          @cache = Hash.new { |hash,key| hash[key] = self.fetch(key) }
         end
 
         def log_config(direction, source)

data/lib/new_relic/agent/datastores/redis.rb

@@ -6,11 +6,7 @@ module NewRelic
   module Agent
     module Datastores
       module Redis
-        MULTI_OPERATION = 'multi'
-        PIPELINE_OPERATION = 'pipeline'
         BINARY_DATA_PLACEHOLDER = "<binary data>"
-        PRODUCT_NAME = 'Redis'
-        CONNECT = 'connect'
 
         MAXIMUM_COMMAND_LENGTH = 1000
         MAXIMUM_ARGUMENT_LENGTH = 64

data/lib/new_relic/agent/distributed_tracing.rb

@@ -24,72 +24,6 @@ module NewRelic
       extend NewRelic::SupportabilityHelper
       extend self
       
-      # Create a payload object containing the current transaction's
-      # tracing properties (e.g., duration, priority).  You can use
-      # this object to generate headers to inject into a network
-      # request, so that the downstream service can participate in a
-      # distributed trace.
-      #
-      # @return [DistributedTracePayload] Payload for the current
-      #                                   transaction, or +nil+ if we
-      #                                   could not create the payload
-      #
-      # @api public
-      #
-      # @deprecated See {#create_distributed_trace_headers} instead.
-      #
-      def create_distributed_trace_payload
-        Deprecator.deprecate :create_distributed_trace_payload, :create_distributed_trace_headers
-
-        unless Agent.config[:'distributed_tracing.enabled']
-          NewRelic::Agent.logger.warn "Not configured to create New Relic distributed trace payload"
-          return nil
-        end
-
-        return unless transaction = Transaction.tl_current
-        transaction.distributed_tracer.create_distributed_trace_payload
-      rescue => e
-        NewRelic::Agent.logger.error 'error during create_distributed_trace_payload', e
-        nil
-      end
-
-      # Decode a JSON string containing distributed trace properties
-      # (e.g., calling application, priority) and apply them to the
-      # current transaction.  You can use it to receive distributed
-      # tracing information protocols the agent does not already
-      # support.
-      #
-      # This method will fail if you call it after calling
-      # {#create_distributed_trace_payload}.
-      #
-      # @param payload [String] Incoming distributed trace payload,
-      #                         either as a JSON string or as a
-      #                         header-friendly string returned from
-      #                         {DistributedTracePayload#http_safe}
-      #
-      # @return nil
-      #
-      # @api public
-      #
-      # @deprecated See {#accept_distributed_trace_headers} instead
-      #
-      def accept_distributed_trace_payload payload
-        Deprecator.deprecate :accept_distributed_trace_payload, :accept_distributed_trace_headers
-
-        unless Agent.config[:'distributed_tracing.enabled']
-          NewRelic::Agent.logger.warn "Not configured to accept New Relic distributed trace payload"
-          return nil
-        end
-
-        return unless transaction = Transaction.tl_current
-        transaction.distributed_tracer.accept_distributed_trace_payload(payload)
-        nil
-      rescue => e
-        NewRelic::Agent.logger.error 'error during accept_distributed_trace_payload', e
-        nil
-      end
-
-
       # Adds the Distributed Trace headers so that the downstream service can participate in a
       # distributed trace. This method should be called every time an outbound call is made
       # since the header payload contains a timestamp.

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

@@ -92,22 +92,6 @@ DependencyDetection.defer do
       !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
   end
 
-
-  depends_on do
-    # If the deprecated :disable_active_record_4 setting is true, and
-    # the active record version is four, disable!
-    NewRelic::Agent.config[:disable_active_record_4] == false \
-        || ::ActiveRecord::VERSION::MAJOR.to_i != 4
-  end
-
-  depends_on do
-    # If the deprecated :disable_active_record_5 setting is true, and
-    # the active record version is five, disable!
-    NewRelic::Agent.config[:disable_active_record_5] == false \
-        || ::ActiveRecord::VERSION::MAJOR.to_i  != 5
-  end
-
-
   executes do
     ::NewRelic::Agent.logger.info 'Installing notifications based Active Record instrumentation'
   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,158 +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
-
-        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
     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