newrelic_rpm 6.8.0.360 → 9.2.2

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

@@ -0,0 +1,142 @@
+# 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 Rake
+        module Tracer
+          def invoke_with_newrelic_tracing(*args)
+            unless NewRelic::Agent::Instrumentation::Rake.should_trace?(name)
+              return yield
+            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 yield
+            end
+
+            NewRelic::Agent::Instrumentation::Rake.before_invoke_transaction(self)
+
+            NewRelic::Agent::Tracer.in_transaction(name: "OtherTransaction/Rake/invoke/#{name}", category: :rake) do
+              NewRelic::Agent::Instrumentation::Rake.record_attributes(args, self)
+              yield
+            end
+          end
+        end
+
+        module_function
+
+        def should_install?
+          safe_from_third_party_gem?
+        end
+
+        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
+
+        def should_trace?(name)
+          NewRelic::Agent.config[:'rake.tasks'].any? do |regex|
+            regex.match(name)
+          end
+        end
+
+        def instrument_execute_on_prereqs(task)
+          task.prerequisite_tasks.each do |child_task|
+            instrument_execute(child_task)
+          end
+        end
+
+        def 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 instrument_invoke_prerequisites_concurrently(task)
+          task.instance_eval do
+            def invoke_prerequisites_concurrently(*_)
+              NewRelic::Agent::MethodTracer.trace_execution_scoped('Rake/execute/multitask') do
+                super
+              end
+            end
+          end
+        end
+
+        def before_invoke_transaction(task)
+          ensure_at_exit
+
+          instrument_execute_on_prereqs(task)
+          if task.application.options.always_multitask
+            instrument_invoke_prerequisites_concurrently(task)
+          end
+        rescue => e
+          NewRelic::Agent.logger.error('Error during Rake task invoke', e)
+        end
+
+        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)
+          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 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 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.
+            # 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# 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
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Rake::Tracer
+      def invoke(*args)
+        invoke_with_newrelic_tracing(*args) { super }
+      end
+    end
+  end
+end

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
+  @name = :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).nil?
+  end
+end

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

@@ -0,0 +1,94 @@
+# 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)
+      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)
+      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