newrelic_rpm 7.0.0 → 9.0.0

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,21 +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)
   end
 
   depends_on do
@@ -24,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

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

@@ -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
@@ -6,28 +5,30 @@
 module NewRelic::Agent::Instrumentation
   module Resque
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-    
+
     def with_tracing
       begin
         perform_action_with_newrelic_trace(
           :name => 'perform',
           :class_name => self.payload_class,
-          :category => 'OtherTransaction/ResqueJob') do
-
+          :category => 'OtherTransaction/ResqueJob'
+        ) do
           NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
             args,
             :'job.resque.args',
-            NewRelic::Agent::AttributeFilter::DST_NONE)
+            NewRelic::Agent::AttributeFilter::DST_NONE
+          )
 
           yield
         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
+        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

@@ -1,11 +1,10 @@
-# 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 Prepend 
+    module Prepend
       include NewRelic::Agent::Instrumentation::Resque
 
       def perform

data/lib/new_relic/agent/instrumentation/resque.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 'resque/instrumentation'
 require_relative 'resque/chain'
@@ -10,16 +10,21 @@ 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
@@ -27,29 +32,33 @@ DependencyDetection.defer do
 
   executes do
     if use_prepend?
-      prepend_instrument ::Resque::Job, NewRelic::Agent::Instrumentation::Resque::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/sequel.rb

@@ -1,50 +1,47 @@
 # -*- ruby -*-
-# 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
 
 DependencyDetection.defer do
   @name = :sequel
 
   depends_on do
-    defined?(::Sequel)
+    defined?(Sequel)
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_sequel_instrumentation] &&
-    !NewRelic::Agent.config[:disable_database_instrumentation]
+    !NewRelic::Agent.config[:disable_sequel_instrumentation]
   end
 
   def supported_sequel_version?
-    Sequel.const_defined?( :MAJOR ) &&
-      ( Sequel::MAJOR > 3 ||
-        Sequel::MAJOR == 3 && Sequel::MINOR >= 37 )
+    Sequel.const_defined?(:MAJOR) &&
+      (Sequel::MAJOR > 3 ||
+        Sequel::MAJOR == 3 && Sequel::MINOR >= 37)
   end
 
   executes do
     if supported_sequel_version?
 
-      ::NewRelic::Agent.logger.info 'Installing Sequel instrumentation'
+      NewRelic::Agent.logger.info('Installing Sequel instrumentation')
 
-      if Sequel::Database.respond_to?( :extension )
-        Sequel::Database.extension :newrelic_instrumentation
+      if Sequel::Database.respond_to?(:extension)
+        Sequel::Database.extension(:new_relic_instrumentation)
       else
-        NewRelic::Agent.logger.info "Detected Sequel version %s." % [ Sequel::VERSION ]
-        NewRelic::Agent.logger.info "Please see additional documentation: " +
-          "https://newrelic.com/docs/ruby/sequel-instrumentation"
+        NewRelic::Agent.logger.info("Detected Sequel version %s." % [Sequel::VERSION])
+        NewRelic::Agent.logger.info("Please see additional documentation: " +
+          "https://newrelic.com/docs/ruby/sequel-instrumentation")
       end
 
-      Sequel.synchronize{Sequel::DATABASES.dup}.each do |db|
-        db.extension :newrelic_instrumentation
+      Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|
+        db.extension(:new_relic_instrumentation)
       end
 
-      Sequel::Model.plugin(:newrelic_instrumentation) if defined?(Sequel::Model)
+      Sequel::Model.plugin(:new_relic_instrumentation) if defined?(Sequel::Model)
     else
 
-      NewRelic::Agent.logger.info "Sequel instrumentation requires at least version 3.37.0."
+      NewRelic::Agent.logger.info("Sequel instrumentation requires at least version 3.37.0.")
 
     end
-
   end
-
 end

data/lib/new_relic/agent/instrumentation/sequel_helper.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
   module Agent
@@ -33,4 +33,4 @@ module NewRelic
       end
     end
   end
-end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/client.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::Sidekiq
+  class Client
+    include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
+
+    def call(_worker_class, job, *_)
+      job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+      yield
+    end
+
+    def distributed_tracing_headers
+      headers = {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+      headers
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/extensions/delayed_class.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
+
+# TODO: remove this class once Sidekiq v6 is no longer supported.
+#       Delayed extensions are disabled by default in Sidekiq 5 and 6 and
+#       were removed entirely in Sidekiq 7.
+#
+#       see https://github.com/mperham/sidekiq/issues/5076 for the discussion
+#       of the removal, which includes mentions of alternatives
+if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
+  class Sidekiq::Extensions::DelayedClass
+    def newrelic_trace_args(msg, queue)
+      (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)
+        YAML.unsafe_load(msg['args'][0])
+      else
+        YAML.load(msg['args'][0])
+      end
+
+      {
+        :name => method_name,
+        :class_name => target.name,
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    rescue => e
+      NewRelic::Agent.logger.error("Failure during deserializing YAML for Sidekiq::Extensions::DelayedClass", e)
+      NewRelic::Agent::Instrumentation::Sidekiq::Server.default_trace_args(msg)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sidekiq/server.rb

@@ -0,0 +1,37 @@
+# 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::Sidekiq
+  class Server
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
+
+    # Client middleware has additional parameters, and our tests use the
+    # middleware client-side to work inline.
+    def call(worker, msg, queue, *_)
+      trace_args = if worker.respond_to?(:newrelic_trace_args)
+        worker.newrelic_trace_args(msg, queue)
+      else
+        self.class.default_trace_args(msg)
+      end
+      trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
+
+      perform_action_with_newrelic_trace(trace_args) do
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
+          NewRelic::Agent::AttributeFilter::DST_NONE)
+
+        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, "Other") if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
+        yield
+      end
+    end
+
+    def self.default_trace_args(msg)
+      {
+        :name => 'perform',
+        :class_name => msg['class'],
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    end
+  end
+end