newrelic_rpm 8.2.0 → 9.0.0

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

@@ -1,6 +1,6 @@
-# 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/instrumentation/middleware_proxy'
 
@@ -8,15 +8,15 @@ DependencyDetection.defer do
   named :rails_middleware
 
   depends_on do
-    !::NewRelic::Agent.config[:disable_middleware_instrumentation]
+    !NewRelic::Agent.config[:disable_middleware_instrumentation]
   end
 
   depends_on do
-    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i >= 3
+    defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR.to_i >= 3
   end
 
   executes do
-    ::NewRelic::Agent.logger.info("Installing Rails 3+ middleware instrumentation")
+    NewRelic::Agent.logger.info("Installing Rails 3+ middleware instrumentation")
     module ActionDispatch
       class MiddlewareStack
         class Middleware

data/lib/new_relic/agent/instrumentation/rails_notifications/action_cable.rb

@@ -1,6 +1,7 @@
-# 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/instrumentation/action_cable_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
@@ -8,9 +9,9 @@ DependencyDetection.defer do
   @name = :action_cable_notifications
 
   depends_on do
-    defined?(::Rails::VERSION::MAJOR) &&
-     ::Rails::VERSION::MAJOR.to_i >= 5 &&
-       defined?(::ActionCable)
+    defined?(ActionCable::VERSION::MAJOR) &&
+      ActionCable::VERSION::MAJOR.to_i >= 5 &&
+      defined?(ActiveSupport)
   end
 
   depends_on do
@@ -19,17 +20,17 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing notifications based Action Cable instrumentation'
+    NewRelic::Agent.logger.info('Installing notifications based Action Cable instrumentation')
   end
 
   executes do
     # enumerate the specific events we want so that we do not get unexpected additions in the future
-    ActiveSupport::Notifications.subscribe(/(perform_action|transmit)\.action_cable/,
+    ActiveSupport::Notifications.subscribe(/\A(?:perform_action|transmit|broadcast)\.action_cable\z/,
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
     ActiveSupport.on_load(:action_cable) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::Engine) if defined?(::ActionCable::Engine)
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::RemoteConnections) if defined?(::ActionCable::RemoteConnections)
+      NewRelic::Agent::PrependSupportability.record_metrics_for(ActionCable::Engine) if defined?(ActionCable::Engine)
+      NewRelic::Agent::PrependSupportability.record_metrics_for(ActionCable::RemoteConnections) if defined?(ActionCable::RemoteConnections)
     end
   end
 end

data/lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb

@@ -1,23 +1,25 @@
-# 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/instrumentation/action_controller_subscriber'
+require 'new_relic/agent/instrumentation/action_controller_other_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
-
 DependencyDetection.defer do
   @name = :action_controller_notifications
 
   depends_on do
-    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i >= 4
+    defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR.to_i >= 4
   end
 
   depends_on do
-    defined?(ActionController) && (defined?(ActionController::Base) || defined?(ActionController::API))
+    !NewRelic::Agent.config[:disable_action_controller] &&
+      defined?(ActionController) && (defined?(ActionController::Base) || defined?(ActionController::API))
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing notifications based Action Controller instrumentation'
+    NewRelic::Agent.logger.info('Installing notifications based Action Controller instrumentation')
   end
 
   executes do
@@ -29,5 +31,15 @@ DependencyDetection.defer do
 
     NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
       .subscribe(/^process_action.action_controller$/)
+
+    subs = %w[send_file
+      send_data
+      redirect_to
+      halted_callback
+      unpermitted_parameters]
+
+    # have to double escape period because its going from string -> regex
+    NewRelic::Agent::Instrumentation::ActionControllerOtherSubscriber \
+      .subscribe(Regexp.new("^(#{subs.join('|')})\\.action_controller$"))
   end
 end

data/lib/new_relic/agent/instrumentation/rails_notifications/action_view.rb

@@ -1,6 +1,7 @@
-# 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/instrumentation/action_view_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
@@ -8,7 +9,7 @@ DependencyDetection.defer do
   @name = :action_view_notifications
 
   depends_on do
-    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i >= 4
+    defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR.to_i >= 4
   end
 
   depends_on do
@@ -17,11 +18,13 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing notification based Action View instrumentation'
+    NewRelic::Agent.logger.info('Installing notification based Action View instrumentation')
   end
 
   executes do
-    NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
-    NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionView::Base, ::ActionView::Template, ::ActionView::Renderer)
+    ActiveSupport.on_load(:action_view) do
+      NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
+      NewRelic::Agent::PrependSupportability.record_metrics_for(ActionView::Base, ActionView::Template, ActionView::Renderer)
+    end
   end
 end

data/lib/new_relic/agent/instrumentation/rails_notifications/custom_events.rb

@@ -0,0 +1,30 @@
+# 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/instrumentation/custom_events_subscriber'
+require 'new_relic/agent/prepend_supportability'
+
+DependencyDetection.defer do
+  @name = :custom_event_notifications
+
+  depends_on do
+    defined?(ActiveSupport::Notifications) &&
+      defined?(ActiveSupport::IsolatedExecutionState)
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:active_support_custom_events_names].empty? &&
+      !NewRelic::Agent::Instrumentation::CustomEventsSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing notifications based ActiveSupport custom events instrumentation')
+  end
+
+  executes do
+    NewRelic::Agent.config[:active_support_custom_events_names].each do |name|
+      ActiveSupport::Notifications.subscribe(name, NewRelic::Agent::Instrumentation::CustomEventsSubscriber.new)
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
-# 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::Agent::Instrumentation
   module Rake
@@ -8,7 +8,7 @@ module NewRelic::Agent::Instrumentation
       def self.instrument!
         ::Rake::Task.class_eval do
           include NewRelic::Agent::Instrumentation::Rake::Tracer
-          alias_method :invoke_without_newrelic, :invoke
+          alias_method(:invoke_without_newrelic, :invoke)
 
           def invoke(*args)
             invoke_with_newrelic_tracing(*args) { invoke_without_newrelic(*args) }
@@ -18,8 +18,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-
-
-
-
-

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

@@ -1,4 +1,3 @@
-# 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
@@ -9,7 +8,7 @@ module NewRelic
       module Rake
         module Tracer
           def invoke_with_newrelic_tracing(*args)
-            unless NewRelic::Agent::Instrumentation::Rake.should_trace? name
+            unless NewRelic::Agent::Instrumentation::Rake.should_trace?(name)
               return yield
             end
 
@@ -38,6 +37,7 @@ module NewRelic
 
         def safe_from_third_party_gem?
           return true unless NewRelic::LanguageSupport.bundled_gem?("newrelic-rake")
+
           ::NewRelic::Agent.logger.info("Not installing New Relic supported Rake instrumentation because the third party newrelic-rake gem is present")
           false
         end
@@ -73,10 +73,6 @@ module NewRelic
           task.instance_eval do
             def invoke_prerequisites_concurrently(*_)
               NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/multitask") do
-                prereqs = self.prerequisite_tasks.map(&:name).join(", ")
-                if txn = ::NewRelic::Agent::Tracer.current_transaction
-                  txn.current_segment.params[:statement] = NewRelic::Agent::Database.truncate_query("Couldn't trace concurrent prereq tasks: #{prereqs}")
-                end
                 super
               end
             end
@@ -86,12 +82,9 @@ module NewRelic
         def before_invoke_transaction(task)
           ensure_at_exit
 
-          # We can't represent overlapping operations yet, so if multitask just
-          # make one node and annotate with prereq task names
+          instrument_execute_on_prereqs(task)
           if task.application.options.always_multitask
             instrument_invoke_prerequisites_concurrently(task)
-          else
-            instrument_execute_on_prereqs(task)
           end
         rescue => e
           NewRelic::Agent.logger.error("Error during Rake task invoke", e)
@@ -99,14 +92,14 @@ module NewRelic
 
         def record_attributes(args, task)
           command_line = task.application.top_level_tasks.join(" ")
-          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes({ :command => command_line },
-                                                                        :'job.rake',
-                                                                        NewRelic::Agent::AttributeFilter::DST_NONE)
+          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes({:command => command_line},
+            :'job.rake',
+            NewRelic::Agent::AttributeFilter::DST_NONE)
           named_args = name_the_args(args, task.arg_names)
           unless named_args.empty?
             NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(named_args,
-                                                                          :'job.rake.args',
-                                                                          NewRelic::Agent::AttributeFilter::DST_NONE)
+              :'job.rake.args',
+              NewRelic::Agent::AttributeFilter::DST_NONE)
           end
         rescue => e
           NewRelic::Agent.logger.error("Error during Rake task attribute recording.", e)
@@ -133,7 +126,12 @@ module NewRelic
           at_exit do
             # The agent's default at_exit might not default to installing, but
             # if we are running an instrumented rake task, we always want it.
+            # No code coverage, as the strategy for mocking Kernel.exit prevents
+            # the at_exit block from being executed, and not mocking results in
+            # an early unwanted exit of MiniTest.
+            # :nocov:
             NewRelic::Agent.shutdown
+            # :nocov:
           end
 
           @installed_at_exit = true
@@ -141,4 +139,4 @@ module NewRelic
       end
     end
   end
-end
+end

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

@@ -1,6 +1,6 @@
-# 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::Agent::Instrumentation
   module Rake

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

@@ -1,6 +1,6 @@
-# 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 'rake/instrumentation'
 require_relative 'rake/chain'
@@ -8,22 +8,22 @@ require_relative 'rake/prepend'
 
 DependencyDetection.defer do
   # Why not :rake? newrelic-rake used that name, so avoid conflicting
-  named :rake_instrumentation
+  @name = :rake_instrumentation
   configure_with :rake
 
-  depends_on { defined?(::Rake) && defined?(::Rake::VERSION) }
-  depends_on { Gem::Version.new(::Rake::VERSION) >= Gem::Version.new("10.0.0") }
-  depends_on { ::NewRelic::Agent.config[:'rake.tasks'].any? }
-  depends_on { ::NewRelic::Agent::Instrumentation::Rake.safe_from_third_party_gem? }
+  depends_on { defined?(Rake) && defined?(Rake::VERSION) }
+  depends_on { Gem::Version.new(Rake::VERSION) >= Gem::Version.new("10.0.0") }
+  depends_on { NewRelic::Agent.config[:'rake.tasks'].any? }
+  depends_on { NewRelic::Agent::Instrumentation::Rake.safe_from_third_party_gem? }
 
   executes do
-    ::NewRelic::Agent.logger.info  "Installing Rake instrumentation"
-    ::NewRelic::Agent.logger.debug "Instrumenting Rake tasks: #{::NewRelic::Agent.config[:'rake.tasks']}"
+    NewRelic::Agent.logger.info("Installing Rake instrumentation")
+    NewRelic::Agent.logger.debug("Instrumenting Rake tasks: #{NewRelic::Agent.config[:'rake.tasks']}")
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::Rake::Task, NewRelic::Agent::Instrumentation::Rake::Prepend
+      prepend_instrument Rake::Task, NewRelic::Agent::Instrumentation::Rake::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Rake::Chain
     end

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

@@ -1,29 +1,40 @@
-# 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::Agent::Instrumentation
   module Redis
-    module Chain 
+    module Chain
       def self.instrument!
         ::Redis::Client.class_eval do
           include NewRelic::Agent::Instrumentation::Redis
 
-          alias_method :call_without_new_relic, :call
-    
-          def call(*args, &block)
-            call_with_tracing(args[0]) { call_without_new_relic(*args, &block) }
+          if method_defined?(:call_v)
+            alias_method(:call_v_without_new_relic, :call_v)
+
+            def call_v(*args, &block)
+              call_with_tracing(args[0]) { call_v_without_new_relic(*args, &block) }
+            end
           end
-      
-          alias_method :call_pipeline_without_new_relic, :call_pipeline
-    
-          def call_pipeline(*args, &block)
-            call_pipeline_with_tracing(args[0]) { call_pipeline_without_new_relic(*args, &block) }
+
+          if method_defined?(:call)
+            alias_method(:call_without_new_relic, :call)
+
+            def call(*args, &block)
+              call_with_tracing(args[0]) { call_without_new_relic(*args, &block) }
+            end
           end
 
-          alias_method :connect_without_new_relic, :connect
-    
+          if method_defined?(:call_pipeline)
+            alias_method(:call_pipeline_without_new_relic, :call_pipeline)
+
+            def call_pipeline(*args, &block)
+              call_pipeline_with_tracing(args[0]) { call_pipeline_without_new_relic(*args, &block) }
+            end
+          end
+
+          alias_method(:connect_without_new_relic, :connect)
+
           def connect(*args, &block)
             connect_with_tracing { connect_without_new_relic(*args, &block) }
           end
@@ -31,4 +42,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

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

@@ -0,0 +1,17 @@
+# 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::Redis
+  class Constants
+    PRODUCT_NAME = 'Redis'
+    CONNECT = 'connect'
+    UNKNOWN = 'unknown'
+    LOCALHOST = 'localhost'
+    MULTI_OPERATION = 'multi'
+    PIPELINE_OPERATION = 'pipeline'
+    HAS_REDIS_CLIENT = defined?(::Redis) &&
+      Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('5.0.0') &&
+      !!defined?(::RedisClient)
+  end
+end

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

@@ -1,65 +1,93 @@
-# 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 'constants'
+
 module NewRelic::Agent::Instrumentation
   module Redis
-    PRODUCT_NAME = 'Redis'
-    CONNECT = 'connect'
-    UNKNOWN = "unknown"
-    LOCALHOST = "localhost"
-    MULTI_OPERATION = 'multi'
-    PIPELINE_OPERATION = 'pipeline'
+    def connect_with_tracing
+      with_tracing(Constants::CONNECT, database: db) { yield }
+    end
 
-    def call_with_tracing command, &block
+    def call_with_tracing(command, &block)
       operation = command[0]
       statement = ::NewRelic::Agent::Datastores::Redis.format_command(command)
 
-      with_tracing(operation, statement) { yield }
+      with_tracing(operation, statement: statement, database: db) { yield }
     end
 
-    def call_pipeline_with_tracing pipeline
-      operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? MULTI_OPERATION : PIPELINE_OPERATION
+    # 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) { yield }
+      with_tracing(operation, statement: statement, database: db) { yield }
     end
 
-    def connect_with_tracing
-      with_tracing(CONNECT) { yield }
+    # 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
+    def with_tracing(operation, statement: nil, database: nil)
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
-        product: PRODUCT_NAME,
+        product: Constants::PRODUCT_NAME,
         operation: operation,
         host: _nr_hostname,
         port_path_or_id: _nr_port_path_or_id,
-        database_name: db
+        database_name: database
       )
       begin
         segment.notice_nosql_statement(statement) if statement
         NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
       ensure
-        segment.finish if segment
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
       end
     end
 
     def _nr_hostname
-      self.path ? LOCALHOST : self.host
+      _nr_redis_client_config.path ? Constants::LOCALHOST : _nr_redis_client_config.host
     rescue => e
-      NewRelic::Agent.logger.debug "Failed to retrieve Redis host: #{e}"
-      UNKNOWN
+      NewRelic::Agent.logger.debug("Failed to retrieve Redis host: #{e.class} - #{e.message}")
+      Constants::UNKNOWN
     end
 
     def _nr_port_path_or_id
-      self.path || self.port
+      _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}"
-      UNKNOWN
+      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)
+          client && client.config
+        # 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
+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

@@ -1,4 +1,3 @@
-# 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
@@ -8,17 +7,23 @@ module NewRelic::Agent::Instrumentation
     module Prepend
       include NewRelic::Agent::Instrumentation::Redis
 
-      def call *args, &block
+      # Defined in version 5.x+
+      def call_v(*args, &block)
         call_with_tracing(args[0]) { super }
       end
 
-      def call_pipeline *args, &block
+      # 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
+      def connect(*args, &block)
         connect_with_tracing { super }
       end
     end
   end
-end
+end

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

@@ -1,25 +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'
 
 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) && defined?(::Redis::VERSION)
+    defined?(Redis) && defined?(Redis::VERSION)
   end
 
   conflicts_with_prepend do
-    defined?(::PrometheusExporter)
+    defined?(PrometheusExporter)
   end
 
   depends_on do
@@ -28,9 +30,13 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing Redis Instrumentation'
+    NewRelic::Agent.logger.info('Installing Redis Instrumentation')
+    if NewRelic::Agent::Instrumentation::Redis::Constants::HAS_REDIS_CLIENT
+      RedisClient.register(NewRelic::Agent::Instrumentation::RedisClient::Middleware)
+    end
+
     if use_prepend?
-      prepend_instrument ::Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
+      prepend_instrument Redis::Client, NewRelic::Agent::Instrumentation::Redis::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::Redis::Chain
     end

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

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