newrelic_rpm 9.1.0 → 9.21.0

data/lib/new_relic/agent/instrumentation/redis/cluster_middleware.rb

@@ -0,0 +1,26 @@
+# 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 RedisClient
+    module ClusterMiddleware
+      include NewRelic::Agent::Instrumentation::Redis
+
+      # Until we decide to move our Redis instrumentation entirely off patches
+      # keep the middleware instrumentation for the call and connect methods
+      # limited to the redis-clustering instrumentation.
+      #
+      # Redis's middleware option does not capture errors as high in the stack
+      # as our patches. Leaving the patches for call and connect on the main
+      # Redis gem limits the feature disparity our customers experience.
+      def call(*args, &block)
+        call_with_tracing(args[0]) { super }
+      end
+
+      def connect(*args, &block)
+        connect_with_tracing { super }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/redis/constants.rb

@@ -6,12 +6,12 @@ module NewRelic::Agent::Instrumentation::Redis
   class Constants
     PRODUCT_NAME = 'Redis'
     CONNECT = 'connect'
-    UNKNOWN = 'unknown'
+    UNKNOWN = NewRelic::UNKNOWN_LOWER
     LOCALHOST = 'localhost'
     MULTI_OPERATION = 'multi'
     PIPELINE_OPERATION = 'pipeline'
     HAS_REDIS_CLIENT = defined?(::Redis) &&
-      Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('5.0.0') &&
+      NewRelic::Helper.version_satisfied?(::Redis::VERSION, '>=', '5.0.0') &&
       !defined?(::RedisClient).nil?
   end
 end

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

@@ -6,15 +6,17 @@ require_relative 'constants'
 
 module NewRelic::Agent::Instrumentation
   module Redis
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def connect_with_tracing
-      with_tracing(Constants::CONNECT, database: db) { yield }
+      with_tracing(Constants::CONNECT, database: _nr_db) { yield }
     end
 
     def call_with_tracing(command, &block)
       operation = command[0]
       statement = ::NewRelic::Agent::Datastores::Redis.format_command(command)
 
-      with_tracing(operation, statement: statement, database: db) { yield }
+      with_tracing(operation, statement: statement, database: _nr_db) { yield }
     end
 
     # Used for Redis 4.x and 3.x
@@ -22,27 +24,22 @@ module NewRelic::Agent::Instrumentation
       operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? Constants::MULTI_OPERATION : Constants::PIPELINE_OPERATION
       statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline.commands)
 
-      with_tracing(operation, statement: statement, database: db) { yield }
+      with_tracing(operation, statement: statement, database: _nr_db) { yield }
     end
 
     # Used for Redis 5.x+
     def call_pipelined_with_tracing(pipeline)
-      db = begin
-        _nr_redis_client_config.db
-      rescue StandardError => e
-        NewRelic::Agent.logger.error("Failed to determine configured Redis db value: #{e.class} - #{e.message}")
-        nil
-      end
-
       operation = pipeline.flatten.include?('MULTI') ? Constants::MULTI_OPERATION : Constants::PIPELINE_OPERATION
       statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline)
 
-      with_tracing(operation, statement: statement, database: db) { yield }
+      with_tracing(operation, statement: statement, database: _nr_db) { yield }
     end
 
     private
 
     def with_tracing(operation, statement: nil, database: nil)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: Constants::PRODUCT_NAME,
         operation: operation,
@@ -90,5 +87,15 @@ module NewRelic::Agent::Instrumentation
         config
       end
     end
+
+    def _nr_db
+      # db is a method on the Redis client in versions < 5.x
+      return db if respond_to?(:db)
+      # db is accessible through the RedisClient::Config object in versions > 5.x
+      return _nr_redis_client_config.db if _nr_redis_client_config.respond_to?(:db)
+    rescue StandardError => e
+      NewRelic::Agent.logger.debug("Failed to determine configured Redis db value: #{e.class} - #{e.message}")
+      nil
+    end
   end
 end

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

@@ -6,6 +6,9 @@ module NewRelic::Agent::Instrumentation
   module RedisClient
     module Middleware
       # This module is used to instrument Redis 5.x+
+      #
+      # It only instruments call_pipelined because connect and call are accessed
+      # too late in the stack to capture all errors
       include NewRelic::Agent::Instrumentation::Redis
 
       def call_pipelined(*args, &block)

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

@@ -10,6 +10,7 @@ require_relative 'redis/chain'
 require_relative 'redis/constants'
 require_relative 'redis/prepend'
 require_relative 'redis/middleware'
+require_relative 'redis/cluster_middleware'
 
 DependencyDetection.defer do
   # Why not :redis? newrelic-redis used that name, so avoid conflicting
@@ -30,15 +31,20 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing Redis Instrumentation')
     if NewRelic::Agent::Instrumentation::Redis::Constants::HAS_REDIS_CLIENT
       RedisClient.register(NewRelic::Agent::Instrumentation::RedisClient::Middleware)
+
+      if defined?(Redis::Cluster::Client)
+        RedisClient.register(NewRelic::Agent::Instrumentation::RedisClient::ClusterMiddleware)
+      end
     end
 
-    if use_prepend?
-      prepend_instrument Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
-    else
-      chain_instrument NewRelic::Agent::Instrumentation::Redis::Chain
+    unless defined?(Redis::Cluster::Client)
+      if use_prepend?
+        prepend_instrument Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
+      else
+        chain_instrument NewRelic::Agent::Instrumentation::Redis::Chain
+      end
     end
   end
 end

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

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation
   module Resque
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def with_tracing
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
         perform_action_with_newrelic_trace(
           :name => 'perform',

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

@@ -15,15 +15,17 @@ DependencyDetection.defer do
 
   # Airbrake uses method chaining on Resque::Job on versions < 11.0.3
   conflicts_with_prepend do
-    defined?(Airbrake) && defined?(Airbrake::AIRBRAKE_VERSION) && Gem::Version.create(Airbrake::AIRBRAKE_VERSION) < Gem::Version.create('11.0.3')
+    defined?(Airbrake) && defined?(Airbrake::AIRBRAKE_VERSION) && NewRelic::Helper.version_satisfied?(Airbrake::AIRBRAKE_VERSION, '<', '11.0.3')
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing Resque instrumentation')
-  end
-
-  executes do
-    if NewRelic::Agent.config[:'resque.use_ruby_dns'] && NewRelic::Agent.config[:dispatcher] == :resque
+    if NewRelic::Agent.config[:'resque.use_ruby_dns'] &&
+        NewRelic::Agent.config[:dispatcher] == :resque &&
+        # resolv-replace is no longer part of the language in Ruby 3.4.
+        # we don't believe this lib is still necessary for Ruby 3.4 users.
+        # however, if we receive customer feedback to the contrary, we can find
+        # an alternate approach.
+        NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '3.4')
       NewRelic::Agent.logger.info('Requiring resolv-replace')
       require 'resolv'
       require 'resolv-replace'

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

@@ -0,0 +1,43 @@
+# 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 Roda
+    module Chain
+      def self.instrument!
+        ::Roda.class_eval do
+          include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+          alias_method(:_roda_handle_main_route_without_tracing, :_roda_handle_main_route)
+
+          def _roda_handle_main_route(*args)
+            _roda_handle_main_route_with_tracing(*args) do
+              _roda_handle_main_route_without_tracing(*args)
+            end
+          end
+        end
+      end
+    end
+
+    module Build
+      module Chain
+        def self.instrument!
+          ::Roda.class_eval do
+            include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+            class << self
+              alias_method(:build_rack_app_without_tracing, :build_rack_app)
+
+              def build_rack_app
+                build_rack_app_with_tracing do
+                  build_rack_app_without_tracing
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/ignorer.rb

@@ -0,0 +1,45 @@
+# 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 Roda
+    module Ignorer
+      def self.should_ignore?(app, type)
+        return false unless app.opts.include?(:newrelic_ignores)
+
+        app.opts[:newrelic_ignores][type].any? do |pattern|
+          pattern === app.request.path_info
+        end
+      end
+
+      def newrelic_ignore(*routes)
+        set_newrelic_ignore(:routes, *routes)
+      end
+
+      def newrelic_ignore_apdex(*routes)
+        set_newrelic_ignore(:apdex, *routes)
+      end
+
+      def newrelic_ignore_enduser(*routes)
+        set_newrelic_ignore(:enduser, *routes)
+      end
+
+      private
+
+      def set_newrelic_ignore(type, *routes)
+        # Create a newrelic_ignores hash if one doesn't exist
+        opts[:newrelic_ignores] = Hash.new([]) if !opts.include?(:newrelic_ignores)
+
+        if routes.empty?
+          opts[:newrelic_ignores][type] += [Regexp.new('.*')]
+        else
+          opts[:newrelic_ignores][type] += routes.map do |r|
+            # Roda adds leading slashes to routes, so we need to do the same
+            "#{'/' unless r.start_with?('/')}#{r}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# 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 Roda
+    module Tracer
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      INSTRUMENTATION_NAME = 'Roda'
+
+      def self.included(clazz)
+        clazz.extend(self)
+      end
+
+      def newrelic_middlewares
+        middlewares = [NewRelic::Rack::BrowserMonitoring]
+        if NewRelic::Rack::AgentHooks.needed?
+          middlewares << NewRelic::Rack::AgentHooks
+        end
+        middlewares
+      end
+
+      def build_rack_app_with_tracing
+        unless NewRelic::Agent.config[:disable_roda_auto_middleware]
+          newrelic_middlewares.each do |middleware_class|
+            self.use middleware_class
+          end
+        end
+        yield
+      end
+
+      # Roda makes use of Rack, so we can get params from the request object
+      def rack_request_params
+        begin
+          @_request.params
+        rescue => e
+          NewRelic::Agent.logger.debug('Failed to get params from Rack request.', e)
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def _roda_handle_main_route_with_tracing(*args)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        perform_action_with_newrelic_trace(
+          category: :roda,
+          name: ::NewRelic::Agent::Instrumentation::Roda::TransactionNamer.transaction_name(request),
+          params: ::NewRelic::Agent::ParameterFiltering::apply_filters(request.env, rack_request_params)
+        ) do
+          yield
+        end
+      end
+
+      def do_not_trace?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :routes)
+      end
+
+      def ignore_apdex?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :apdex)
+      end
+
+      def ignore_enduser?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :enduser)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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 Roda
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+      def _roda_handle_main_route(*args)
+        _roda_handle_main_route_with_tracing(*args) { super }
+      end
+    end
+
+    module Build
+      module Prepend
+        include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+        def build_rack_app
+          build_rack_app_with_tracing { super }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb

@@ -0,0 +1,29 @@
+# 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 Roda
+        module TransactionNamer
+          extend self
+
+          REGEX_MULTIPLE_SLASHES = %r{^[/^]*(.*?)[/$?]*$}.freeze
+
+          def transaction_name(request)
+            path = request.path || ::NewRelic::Agent::UNKNOWN_METRIC
+            name = path.gsub(REGEX_MULTIPLE_SLASHES, '\1') # remove any rogue slashes
+            name = NewRelic::ROOT if name.empty?
+            name = "#{request.request_method} #{name}" if request.respond_to?(:request_method)
+
+            name
+          rescue => e
+            ::NewRelic::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Roda transaction name")
+            ::NewRelic::Agent::UNKNOWN_METRIC
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda.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
+
+require_relative 'roda/instrumentation'
+require_relative 'roda/roda_transaction_namer'
+require_relative 'roda/ignorer'
+
+DependencyDetection.defer do
+  named :roda
+
+  depends_on do
+    defined?(Roda) &&
+      NewRelic::Helper.version_satisfied?(Roda::RodaVersion, '>=', '3.19.0') &&
+      Roda::RodaPlugins::Base::ClassMethods.private_method_defined?(:build_rack_app) &&
+      Roda::RodaPlugins::Base::InstanceMethods.method_defined?(:_roda_handle_main_route)
+  end
+
+  executes do
+    require_relative '../../rack/agent_hooks'
+    require_relative '../../rack/browser_monitoring'
+
+    if use_prepend?
+      require_relative 'roda/prepend'
+
+      supportability_name = NewRelic::Agent::Instrumentation::Roda::Tracer::INSTRUMENTATION_NAME
+      prepend_instrument Roda.singleton_class, NewRelic::Agent::Instrumentation::Roda::Build::Prepend, supportability_name
+      prepend_instrument Roda, NewRelic::Agent::Instrumentation::Roda::Prepend
+    else
+      require_relative 'roda/chain'
+      chain_instrument NewRelic::Agent::Instrumentation::Roda::Build::Chain, supportability_name
+      chain_instrument NewRelic::Agent::Instrumentation::Roda::Chain
+    end
+    Roda.class_eval { extend NewRelic::Agent::Instrumentation::Roda::Ignorer }
+  end
+end

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

@@ -0,0 +1,55 @@
+# 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 RubyKafka::Chain
+    def self.instrument!
+      ::Kafka::Producer.class_eval do
+        include NewRelic::Agent::Instrumentation::RubyKafka
+
+        alias_method(:produce_without_new_relic, :produce)
+
+        def produce(value, **kwargs)
+          produce_with_new_relic(value, **kwargs) do |headers|
+            kwargs[:headers] = headers
+            produce_without_new_relic(value, **kwargs)
+          end
+        end
+      end
+
+      ::Kafka::Consumer.class_eval do
+        include NewRelic::Agent::Instrumentation::RubyKafka
+
+        alias_method(:each_message_without_new_relic, :each_message)
+
+        def each_message(*args)
+          each_message_without_new_relic(*args) do |message|
+            each_message_with_new_relic(message) do
+              yield(message)
+            end
+          end
+        end
+      end
+
+      ::Kafka::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::RubyKafkaConfig
+
+        alias_method(:producer_without_new_relic, :producer)
+        alias_method(:consumer_without_new_relic, :consumer)
+
+        def producer(**kwargs)
+          producer_without_new_relic(**kwargs).tap do |producer|
+            set_nr_config(producer)
+          end
+        end
+
+        def consumer(**kwargs)
+          consumer_without_new_relic(**kwargs).tap do |consumer|
+            set_nr_config(consumer)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# 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 'new_relic/agent/messaging'
+
+module NewRelic::Agent::Instrumentation
+  module RubyKafka
+    MESSAGING_LIBRARY = 'Kafka'
+    PRODUCE = 'Produce'
+    CONSUME = 'Consume'
+
+    INSTRUMENTATION_NAME = 'ruby-kafka'
+
+    def produce_with_new_relic(value, **kwargs)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      topic_name = kwargs[:topic]
+      segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+        action: :produce,
+        library: MESSAGING_LIBRARY,
+        destination_type: :topic,
+        destination_name: topic_name
+      )
+      create_kafka_metrics(action: PRODUCE, topic: topic_name)
+
+      headers = kwargs[:headers] || {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+
+      NewRelic::Agent::Tracer.capture_segment_error(segment) { yield(headers) }
+    ensure
+      segment&.finish
+    end
+
+    def each_message_with_new_relic(message)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      headers = message&.headers || {}
+      topic_name = message&.topic
+
+      NewRelic::Agent::Messaging.wrap_message_broker_consume_transaction(
+        library: MESSAGING_LIBRARY,
+        destination_type: :topic,
+        destination_name: topic_name,
+        headers: headers,
+        action: :consume
+      ) do
+        create_kafka_metrics(action: CONSUME, topic: topic_name)
+        yield
+      end
+    end
+
+    def create_kafka_metrics(action:, topic:)
+      @nr_config.each do |seed_broker|
+        host = "#{seed_broker&.host}:#{seed_broker&.port}"
+        NewRelic::Agent.record_metric("MessageBroker/Kafka/Nodes/#{host}/#{action}/#{topic}", 1)
+        NewRelic::Agent.record_metric("MessageBroker/Kafka/Nodes/#{host}", 1)
+      end
+    end
+  end
+
+  module RubyKafkaConfig
+    def set_nr_config(producer_or_consumer)
+      producer_or_consumer.instance_variable_set(:@nr_config, @seed_brokers)
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# 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 RubyKafkaProducer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::RubyKafka
+
+      def produce(value, **kwargs)
+        produce_with_new_relic(value, **kwargs) do |headers|
+          kwargs[:headers] = headers
+          super
+        end
+      end
+    end
+  end
+
+  module RubyKafkaConsumer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::RubyKafka
+
+      if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '3')
+        def each_message(**args)
+          super do |message|
+            each_message_with_new_relic(message) do
+              yield(message)
+            end
+          end
+        end
+      else
+        def each_message(*args)
+          super do |message|
+            each_message_with_new_relic(message) do
+              yield(message)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  module RubyKafkaClient
+    module Prepend
+      include NewRelic::Agent::Instrumentation::RubyKafkaConfig
+
+      def producer(**kwargs)
+        super.tap do |producer|
+          set_nr_config(producer)
+        end
+      end
+
+      def consumer(**kwargs)
+        super.tap do |consumer|
+          set_nr_config(consumer)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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 'ruby_kafka/instrumentation'
+require_relative 'ruby_kafka/chain'
+require_relative 'ruby_kafka/prepend'
+
+DependencyDetection.defer do
+  named :'ruby_kafka'
+
+  depends_on do
+    defined?(Kafka)
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument Kafka::Producer, NewRelic::Agent::Instrumentation::RubyKafkaProducer::Prepend
+      prepend_instrument Kafka::Consumer, NewRelic::Agent::Instrumentation::RubyKafkaConsumer::Prepend
+      prepend_instrument Kafka::Client, NewRelic::Agent::Instrumentation::RubyKafkaClient::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::RubyKafka::Chain
+    end
+  end
+end