newrelic_rpm 6.15.0 → 9.7.1

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

@@ -0,0 +1,98 @@
+# 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 '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 }
+    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 }
+    end
+
+    # Used for Redis 4.x and 3.x
+    def call_pipeline_with_tracing(pipeline)
+      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 }
+    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 }
+    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,
+        host: _nr_hostname,
+        port_path_or_id: _nr_port_path_or_id,
+        database_name: database
+      )
+      begin
+        segment.notice_nosql_statement(statement) if statement
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
+      end
+    end
+
+    def _nr_hostname
+      _nr_redis_client_config.path ? Constants::LOCALHOST : _nr_redis_client_config.host
+    rescue => e
+      NewRelic::Agent.logger.debug("Failed to retrieve Redis host: #{e.class} - #{e.message}")
+      Constants::UNKNOWN
+    end
+
+    def _nr_port_path_or_id
+      _nr_redis_client_config.path || _nr_redis_client_config.port
+    rescue => e
+      NewRelic::Agent.logger.debug("Failed to retrieve Redis port_path_or_id: #{e.class} - #{e.message}")
+      Constants::UNKNOWN
+    end
+
+    def _nr_redis_client_config
+      @nr_config ||= begin
+        # redis gem
+        config = if defined?(::Redis::Client) && self.is_a?(::Redis::Client)
+          self
+        # redis-client gem v0.11+ (self is a RedisClient::Middlewares)
+        elsif respond_to?(:client)
+          # The following line needs else branch coverage
+          client && client.config # rubocop:disable Style/SafeNavigation
+        # redis-client gem <0.11 (self is a RedisClient::Middlewares)
+        elsif defined?(::RedisClient)
+          ::RedisClient.config if ::RedisClient.respond_to?(:config)
+        end
+        raise 'Unable to locate the underlying Redis client configuration.' unless config
+
+        config
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# 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 Middleware
+      # This module is used to instrument Redis 5.x+
+      include NewRelic::Agent::Instrumentation::Redis
+
+      def call_pipelined(*args, &block)
+        call_pipelined_with_tracing(args[0]) { super }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/redis/prepend.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::Agent::Instrumentation
+  module Redis
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Redis
+
+      # Defined in version 5.x+
+      def call_v(*args, &block)
+        call_with_tracing(args[0]) { super }
+      end
+
+      # Defined in version 4.x, 3.x
+      def call(*args, &block)
+        call_with_tracing(args[0]) { super }
+      end
+
+      def call_pipeline(*args, &block)
+        call_pipeline_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.rb

@@ -1,47 +1,27 @@
-# 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 'new_relic/agent/datastores'
 require 'new_relic/agent/datastores/redis'
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Redis
-        extend self
-
-        UNKNOWN = "unknown".freeze
-        LOCALHOST = "localhost".freeze
-
-        def host_for(client)
-          client.path ? LOCALHOST : client.host
-        rescue => e
-          NewRelic::Agent.logger.debug "Failed to retrieve Redis host: #{e}"
-          UNKNOWN
-        end
-
-        def port_path_or_id_for(client)
-          client.path || client.port
-        rescue => e
-          NewRelic::Agent.logger.debug "Failed to retrieve Redis port_path_or_id: #{e}"
-          UNKNOWN
-        end
-      end
-    end
-  end
-end
+require_relative 'redis/instrumentation'
+require_relative 'redis/chain'
+require_relative 'redis/constants'
+require_relative 'redis/prepend'
+require_relative 'redis/middleware'
 
 DependencyDetection.defer do
   # Why not :redis? newrelic-redis used that name, so avoid conflicting
-  named :redis_instrumentation
+  @name = :redis_instrumentation
+  configure_with :redis
 
   depends_on do
-    defined? ::Redis::VERSION
+    defined?(Redis) && defined?(Redis::VERSION)
   end
 
-  depends_on do
-    NewRelic::Agent.config[:disable_redis] == false
+  conflicts_with_prepend do
+    defined?(PrometheusExporter)
   end
 
   depends_on do
@@ -50,84 +30,15 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing Redis Instrumentation'
-
-    Redis::Client.class_eval do
-      alias_method :call_without_new_relic, :call
-
-      def call(*args, &block)
-        operation = args[0][0]
-        statement = ::NewRelic::Agent::Datastores::Redis.format_command(args[0])
-
-        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-
-        segment = NewRelic::Agent::Tracer.start_datastore_segment(
-          product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-          operation: operation,
-          host: hostname,
-          port_path_or_id: port_path_or_id,
-          database_name: db
-        )
-        begin
-          segment.notice_nosql_statement(statement) if statement
-          NewRelic::Agent::Tracer.capture_segment_error segment do
-            call_without_new_relic(*args, &block)
-          end
-        ensure
-          segment.finish if segment
-        end
-      end
-  
-      alias_method :call_pipeline_without_new_relic, :call_pipeline
-
-      def call_pipeline(*args, &block)
-        pipeline = args[0]
-        operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? NewRelic::Agent::Datastores::Redis::MULTI_OPERATION : NewRelic::Agent::Datastores::Redis::PIPELINE_OPERATION
-        statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline.commands)
-
-        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-
-        segment = NewRelic::Agent::Tracer.start_datastore_segment(
-          product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-          operation: operation,
-          host: hostname,
-          port_path_or_id: port_path_or_id,
-          database_name: db
-        )
-        begin
-          segment.notice_nosql_statement(statement)
-          NewRelic::Agent::Tracer.capture_segment_error segment do
-            call_pipeline_without_new_relic(*args, &block)
-          end
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias_method :connect_without_new_relic, :connect
-
-      def connect(*args, &block)
-        hostname = NewRelic::Agent::Instrumentation::Redis.host_for(self)
-        port_path_or_id = NewRelic::Agent::Instrumentation::Redis.port_path_or_id_for(self)
-
-        segment = NewRelic::Agent::Tracer.start_datastore_segment(
-          product: NewRelic::Agent::Datastores::Redis::PRODUCT_NAME,
-          operation: NewRelic::Agent::Datastores::Redis::CONNECT,
-          host: hostname,
-          port_path_or_id: port_path_or_id,
-          database_name: db
-        )
+    NewRelic::Agent.logger.info('Installing Redis Instrumentation')
+    if NewRelic::Agent::Instrumentation::Redis::Constants::HAS_REDIS_CLIENT
+      RedisClient.register(NewRelic::Agent::Instrumentation::RedisClient::Middleware)
+    end
 
-        begin
-          NewRelic::Agent::Tracer.capture_segment_error segment do
-            connect_without_new_relic(*args, &block)
-          end
-        ensure
-          segment.finish if segment
-        end
-      end
+    if use_prepend?
+      prepend_instrument Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Redis::Chain
     end
   end
 end

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

@@ -0,0 +1,21 @@
+# 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 Resque
+    module Chain
+      def self.instrument!
+        ::Resque::Job.class_eval do
+          include NewRelic::Agent::Instrumentation::Resque
+
+          alias_method(:perform_without_instrumentation, :perform)
+
+          def perform
+            with_tracing { perform_without_instrumentation }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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 Resque
+        module Helper
+          extend self
+
+          def resque_fork_per_job?
+            ENV['FORK_PER_JOB'] != 'false' && NewRelic::LanguageSupport.can_fork?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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 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',
+          :class_name => self.payload_class,
+          :category => 'OtherTransaction/ResqueJob'
+        ) do
+          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
+            args,
+            :'job.resque.args',
+            NewRelic::Agent::AttributeFilter::DST_NONE
+          )
+
+          yield
+        end
+      ensure
+        # Stopping the event loop before flushing the pipe.
+        # The goal is to avoid conflict during write.
+        if NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job?
+          NewRelic::Agent.agent.stop_event_loop
+          NewRelic::Agent.agent.flush_pipe_data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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 Resque
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Resque
+
+      def perform
+        with_tracing { super }
+      end
+    end
+  end
+end

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

@@ -1,75 +1,64 @@
-# 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 'resque/instrumentation'
+require_relative 'resque/chain'
+require_relative 'resque/prepend'
 
 DependencyDetection.defer do
   @name = :resque
 
   depends_on do
-    defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]
+    defined?(Resque::Job)
+  end
+
+  # 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')
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Resque instrumentation'
+    NewRelic::Agent.logger.info('Installing Resque instrumentation')
   end
 
   executes do
     if NewRelic::Agent.config[:'resque.use_ruby_dns'] && NewRelic::Agent.config[:dispatcher] == :resque
-      ::NewRelic::Agent.logger.info 'Requiring resolv-replace'
+      NewRelic::Agent.logger.info('Requiring resolv-replace')
       require 'resolv'
       require 'resolv-replace'
     end
   end
 
   executes do
-    module ::Resque
-      class Job
-        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-        alias_method :perform_without_instrumentation, :perform
-
-        def perform
-          begin
-            perform_action_with_newrelic_trace(
-              :name => 'perform',
-              :class_name => self.payload_class,
-              :category => 'OtherTransaction/ResqueJob') do
-
-              NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
-                args,
-                :'job.resque.args',
-                NewRelic::Agent::AttributeFilter::DST_NONE)
-
-              perform_without_instrumentation
-            end
-          ensure
-            # Stopping the event loop before flushing the pipe.
-            # The goal is to avoid conflict during write.
-            NewRelic::Agent.agent.stop_event_loop
-            NewRelic::Agent.agent.flush_pipe_data
-          end
-        end
-      end
+    if use_prepend?
+      prepend_instrument Resque::Job, NewRelic::Agent::Instrumentation::Resque::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Resque::Chain
     end
 
-    if NewRelic::LanguageSupport.can_fork?
-      ::Resque.before_first_fork do
-        NewRelic::Agent.manual_start(:dispatcher   => :resque,
-                                     :sync_startup => true,
-                                     :start_channel_listener => true)
+    if NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job?
+      Resque.before_first_fork do
+        NewRelic::Agent.manual_start(:dispatcher => :resque,
+          :sync_startup => true,
+          :start_channel_listener => true)
       end
 
-      ::Resque.before_fork do |job|
-        if ENV['FORK_PER_JOB'] != 'false'
-          NewRelic::Agent.register_report_channel(job.object_id)
-        end
+      Resque.before_fork do |job|
+        NewRelic::Agent.register_report_channel(job.object_id)
       end
 
-      ::Resque.after_fork do |job|
+      Resque.after_fork do |job|
         # Only suppress reporting Instance/Busy for forked children
         # Traced errors UI relies on having the parent process report that metric
         NewRelic::Agent.after_fork(:report_to_channel => job.object_id,
-                                   :report_instance_busy => false)
+          :report_instance_busy => false)
+      end
+    else
+      Resque.before_first_fork do
+        NewRelic::Agent.manual_start(:dispatcher => :resque,
+          :sync_startup => true,
+          :start_channel_listener => false)
       end
     end
   end

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