newrelic_rpm 6.13.0 → 7.1.0

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

@@ -0,0 +1,144 @@
+# 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
+    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
+                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 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 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.
+            NewRelic::Agent.shutdown
+          end
+
+          @installed_at_exit = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# 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.
+
+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/redis.rb

@@ -5,43 +5,21 @@
 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/prepend'
 
 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
@@ -51,162 +29,10 @@ DependencyDetection.defer do
 
   executes do
     NewRelic::Agent.logger.info 'Installing Redis Instrumentation'
-
-    Redis::Client.class_eval do
-      alias_method :call_without_new_relic, :call
-
-      if RUBY_VERSION < "2.7.0"
-        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
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_without_new_relic(*args, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      else
-        def call(*args, **kwargs, &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
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_without_new_relic(*args, **kwargs, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      end
-
-
-
-      alias_method :call_pipeline_without_new_relic, :call_pipeline
-
-      if RUBY_VERSION < "2.7.0"
-        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)
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_pipeline_without_new_relic(*args, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      else
-        def call_pipeline(*args, **kwargs, &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)
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              call_pipeline_without_new_relic(*args, **kwargs, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      end
-
-      alias_method :connect_without_new_relic, :connect
-
-      if RUBY_VERSION < "2.7.0"
-        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
-          )
-  
-          begin
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              connect_without_new_relic(*args, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      else
-        def connect(*args, **kwargs, &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
-          )
-  
-          begin
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              connect_without_new_relic(*args, **kwargs, &block)
-            end
-          ensure
-            segment.finish if segment
-          end
-        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/redis/chain.rb

@@ -0,0 +1,34 @@
+# 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 
+      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) }
+          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) }
+          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/instrumentation.rb

@@ -0,0 +1,65 @@
+# 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
+    PRODUCT_NAME = 'Redis'
+    CONNECT = 'connect'
+    UNKNOWN = "unknown"
+    LOCALHOST = "localhost"
+    MULTI_OPERATION = 'multi'
+    PIPELINE_OPERATION = 'pipeline'
+
+    def call_with_tracing command, &block
+      operation = command[0]
+      statement = ::NewRelic::Agent::Datastores::Redis.format_command(command)
+
+      with_tracing(operation, statement) { yield }
+    end
+
+    def call_pipeline_with_tracing pipeline
+      operation = pipeline.is_a?(::Redis::Pipeline::Multi) ? MULTI_OPERATION : PIPELINE_OPERATION
+      statement = ::NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline.commands)
+
+      with_tracing(operation, statement) { yield }
+    end
+
+    def connect_with_tracing
+      with_tracing(CONNECT) { yield }
+    end
+
+    private
+
+    def with_tracing operation, statement=nil
+      segment = NewRelic::Agent::Tracer.start_datastore_segment(
+        product: PRODUCT_NAME,
+        operation: operation,
+        host: _nr_hostname,
+        port_path_or_id: _nr_port_path_or_id,
+        database_name: db
+      )
+      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
+      self.path ? LOCALHOST : self.host
+    rescue => e
+      NewRelic::Agent.logger.debug "Failed to retrieve Redis host: #{e}"
+      UNKNOWN
+    end
+
+    def _nr_port_path_or_id
+      self.path || self.port
+    rescue => e
+      NewRelic::Agent.logger.debug "Failed to retrieve Redis port_path_or_id: #{e}"
+      UNKNOWN
+    end
+  end
+end