newrelic_rpm 6.8.0.360 → 8.13.1

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

@@ -1,171 +1,31 @@
-# 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 'rake/instrumentation'
+require_relative 'rake/chain'
+require_relative 'rake/prepend'
 
 DependencyDetection.defer do
   # Why not :rake? newrelic-rake used that name, so avoid conflicting
   named :rake_instrumentation
+  configure_with :rake
 
-  depends_on do
-    defined?(::Rake) &&
-      ::NewRelic::Agent.config[:'disable_rake'] == false &&
-      ::NewRelic::Agent.config[:'rake.tasks'].any? &&
-      ::NewRelic::Agent::Instrumentation::RakeInstrumentation.should_install?
-  end
+  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
-    module Rake
-      class Task
-        alias_method :invoke_without_newrelic, :invoke
-
-        def invoke(*args)
-          unless NewRelic::Agent::Instrumentation::RakeInstrumentation.should_trace? name
-            return invoke_without_newrelic(*args)
-          end
-
-          begin
-            timeout = NewRelic::Agent.config[:'rake.connect_timeout']
-            NewRelic::Agent.instance.wait_on_connect(timeout)
-          rescue => e
-            NewRelic::Agent.logger.error("Exception in wait_on_connect", e)
-            return invoke_without_newrelic(*args)
-          end
-
-          NewRelic::Agent::Instrumentation::RakeInstrumentation.before_invoke_transaction(self)
-
-          NewRelic::Agent::Tracer.in_transaction(name: "OtherTransaction/Rake/invoke/#{name}", category: :rake) do
-            NewRelic::Agent::Instrumentation::RakeInstrumentation.record_attributes(args, self)
-            invoke_without_newrelic(*args)
-          end
-        end
-      end
-    end
-  end
-end
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module RakeInstrumentation
-        def self.should_install?
-          is_supported_version? && safe_from_third_party_gem?
-        end
-
-        def self.is_supported_version?
-          Gem::Version.new(::Rake::VERSION) >= Gem::Version.new("10.0.0")
-        end
-
-        def self.safe_from_third_party_gem?
-          if 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
-          else
-            true
-          end
-        end
-
-        def self.should_trace?(name)
-          NewRelic::Agent.config[:'rake.tasks'].any? do |regex|
-            regex.match(name)
-          end
-        end
-
-        def self.instrument_execute_on_prereqs(task)
-          task.prerequisite_tasks.each do |child_task|
-            instrument_execute(child_task)
-          end
-        end
-
-        def self.instrument_execute(task)
-          return if task.instance_variable_get(:@__newrelic_instrumented_execute)
-
-          task.instance_variable_set(:@__newrelic_instrumented_execute, true)
-          task.instance_eval do
-            def execute(*args, &block)
-              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
-                super
-              end
-            end
-          end
-
-          instrument_execute_on_prereqs(task)
-        end
-
-        def self.instrument_invoke_prerequisites_concurrently(task)
-          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
-          end
-        end
-
-        def self.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
-          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)
-        end
-
-        def self.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)
-          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)
-          end
-        rescue => e
-          NewRelic::Agent.logger.error("Error during Rake task attribute recording.", e)
-        end
-
-        # Expects literal args passed to the task and array of task names
-        # If names are present without matching args, still sets them with nils
-        def self.name_the_args(args, names)
-          unfulfilled_names_length = names.length - args.length
-          if unfulfilled_names_length > 0
-            args.concat(Array.new(unfulfilled_names_length))
-          end
-
-          result = {}
-          args.zip(names).each_with_index do |(value, key), index|
-            result[key || index.to_s] = value
-          end
-          result
-        end
-
-        def self.ensure_at_exit
-          return if @installed_at_exit
-
-          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.
-            NewRelic::Agent.shutdown
-          end
-
-          @installed_at_exit = true
-        end
-      end
+    if use_prepend?
+      prepend_instrument ::Rake::Task, NewRelic::Agent::Instrumentation::Rake::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Rake::Chain
     end
   end
 end

data/lib/new_relic/agent/instrumentation/redis/chain.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 Redis
+    module Chain
+      def self.instrument!
+        ::Redis::Client.class_eval do
+          include NewRelic::Agent::Instrumentation::Redis
+
+          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
+
+          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
+
+          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
+        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

@@ -0,0 +1,72 @@
+# 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
+    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)
+      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: client.config.db) { yield }
+    end
+
+    private
+
+    def with_tracing(operation, statement: nil, database: nil)
+      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
+        segment.finish if segment
+      end
+    end
+
+    def _nr_hostname
+      _nr_client.path ? Constants::LOCALHOST : _nr_client.host
+    rescue => e
+      NewRelic::Agent.logger.debug("Failed to retrieve Redis host: #{e}")
+      Constants::UNKNOWN
+    end
+
+    def _nr_port_path_or_id
+      _nr_client.path || _nr_client.port
+    rescue => e
+      NewRelic::Agent.logger.debug("Failed to retrieve Redis port_path_or_id: #{e}")
+      Constants::UNKNOWN
+    end
+
+    def _nr_client
+      @nr_client ||= self.is_a?(::Redis::Client) ? self : client.config
+    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/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
+  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