newrelic_rpm 6.8.0.360 → 9.2.2

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/rpm/blob/master/LICENSE for complete details.
+# 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
+    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,78 +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
-          call_without_new_relic(*args, &block)
-        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)
-          call_pipeline_without_new_relic(*args, &block)
-        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
-          connect_without_new_relic(*args, &block)
-        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,34 @@
+# 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
+
+    def with_tracing
+      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,72 +1,64 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# 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
-            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/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/rpm/blob/master/LICENSE for complete details.
+# 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/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -9,22 +9,22 @@ module NewRelic
         extend self
 
         # Fallback if the product cannot be determined
-        DEFAULT_PRODUCT_NAME = "Sequel".freeze
+        DEFAULT_PRODUCT_NAME = 'Sequel'.freeze
 
         # A Sequel adapter is called an "adapter_scheme" and can be accessed from
         # the database:
         #
         #   DB.adapter_scheme
         PRODUCT_NAMES = {
-          :ibmdb => "IBMDB2",
-          :firebird => "Firebird",
-          :informix => "Informix",
-          :jdbc => "JDBC",
-          :mysql => "MySQL",
-          :mysql2 => "MySQL",
-          :oracle => "Oracle",
-          :postgres => "Postgres",
-          :sqlite => "SQLite"
+          :ibmdb => 'IBMDB2',
+          :firebird => 'Firebird',
+          :informix => 'Informix',
+          :jdbc => 'JDBC',
+          :mysql => 'MySQL',
+          :mysql2 => 'MySQL',
+          :oracle => 'Oracle',
+          :postgres => 'Postgres',
+          :sqlite => 'SQLite'
         }.freeze
 
         def product_name_from_adapter(adapter)
@@ -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'] && trace_headers&.any?
+        yield
+      end
+    end
+
+    def self.default_trace_args(msg)
+      {
+        :name => 'perform',
+        :class_name => msg['class'],
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    end
+  end
+end

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

@@ -1,72 +1,56 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'sidekiq/client'
+require_relative 'sidekiq/server'
+require_relative 'sidekiq/extensions/delayed_class'
 
 DependencyDetection.defer do
   @name = :sidekiq
 
   depends_on do
-    defined?(::Sidekiq) && !NewRelic::Agent.config[:disable_sidekiq]
+    defined?(Sidekiq) && !NewRelic::Agent.config[:disable_sidekiq]
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Sidekiq instrumentation'
+    NewRelic::Agent.logger.info('Installing Sidekiq instrumentation')
   end
 
   executes do
-    class NewRelic::SidekiqInstrumentation
-      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-      # 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
-
-        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)
-
-          yield
-        end
-      end
-
-      def self.default_trace_args(msg)
-        {
-          :name => 'perform',
-          :class_name => msg['class'],
-          :category => 'OtherTransaction/SidekiqJob'
-        }
-      end
-    end
-
-    class Sidekiq::Extensions::DelayedClass
-      def newrelic_trace_args(msg, queue)
-        (target, method_name, _args) = YAML.load(msg['args'][0])
-        {
-          :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::SidekiqInstrumentation.default_trace_args(msg)
+    Sidekiq.configure_client do |config|
+      config.client_middleware do |chain|
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
     end
 
     Sidekiq.configure_server do |config|
+      config.client_middleware do |chain|
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
+      end
       config.server_middleware do |chain|
-        chain.add NewRelic::SidekiqInstrumentation
+        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Server)
       end
 
       if config.respond_to?(:error_handlers)
-        config.error_handlers << Proc.new do |error, *_|
+        config.error_handlers << proc do |error, *_|
           NewRelic::Agent.notice_error(error)
         end
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+
+    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated.' \
+      'They will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your Sidekiq version to continue receiving full support. '
+
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_sidekiq_version,
+      deprecation_msg
+    )
+  end
 end