newrelic_rpm 6.15.0 → 8.0.0

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

@@ -2,6 +2,9 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
+require_relative 'curb/chain'
+require_relative 'curb/prepend'
+
 DependencyDetection.defer do
   named :curb
 
@@ -19,246 +22,11 @@ DependencyDetection.defer do
   end
 
   executes do
-    class Curl::Easy
-
-      attr_accessor :_nr_instrumented,
-                    :_nr_failure_instrumented,
-                    :_nr_http_verb,
-                    :_nr_header_str,
-                    :_nr_original_on_header,
-                    :_nr_original_on_complete,
-                    :_nr_original_on_failure,
-                    :_nr_serial
-
-      # We have to hook these three methods separately, as they don't use
-      # Curl::Easy#http
-      def http_head_with_newrelic(*args, &blk)
-        self._nr_http_verb = :HEAD
-        http_head_without_newrelic(*args, &blk)
-      end
-
-
-      alias_method :http_head_without_newrelic, :http_head
-      alias_method :http_head, :http_head_with_newrelic
-
-      def http_post_with_newrelic(*args, &blk)
-        self._nr_http_verb = :POST
-        http_post_without_newrelic(*args, &blk)
-      end
-
-
-      alias_method :http_post_without_newrelic, :http_post
-      alias_method :http_post, :http_post_with_newrelic
-
-      def http_put_with_newrelic(*args, &blk)
-        self._nr_http_verb = :PUT
-        http_put_without_newrelic(*args, &blk)
-      end
-
-
-      alias_method :http_put_without_newrelic, :http_put
-      alias_method :http_put, :http_put_with_newrelic
-
-
-      # Hook the #http method to set the verb.
-      def http_with_newrelic verb
-        self._nr_http_verb = verb.to_s.upcase
-        http_without_newrelic( verb )
-      end
-
-      alias_method :http_without_newrelic, :http
-      alias_method :http, :http_with_newrelic
-
-      # Hook the #perform method to mark the request as non-parallel.
-      def perform_with_newrelic
-        self._nr_http_verb ||= :GET
-        self._nr_serial = true
-        perform_without_newrelic
-      end
-
-      alias_method :perform_without_newrelic, :perform
-      alias_method :perform, :perform_with_newrelic
-
-      # Record the HTTP verb for future #perform calls
-      def method_with_newrelic verb
-        self._nr_http_verb = verb.upcase
-        method_without_newrelic(verb)
-      end
-
-      alias_method :method_without_newrelic, :method
-      alias_method :method, :method_with_newrelic
-
-      # We override this method in order to ensure access to header_str even
-      # though we use an on_header callback
-      def header_str_with_newrelic
-        if self._nr_serial
-          self._nr_header_str
-        else
-          # Since we didn't install a header callback for a non-serial request,
-          # just fall back to the original implementation.
-          header_str_without_newrelic
-        end
-      end
-
-      alias_method :header_str_without_newrelic, :header_str
-      alias_method :header_str, :header_str_with_newrelic
-    end # class Curl::Easy
-
-
-    class Curl::Multi
-      include NewRelic::Agent::MethodTracer
-
-      # Add CAT with callbacks if the request is serial
-      def add_with_newrelic(curl)
-        if curl.respond_to?(:_nr_serial) && curl._nr_serial
-          hook_pending_request(curl) if NewRelic::Agent::Tracer.tracing_enabled?
-        end
-
-        return add_without_newrelic curl
-      end
-
-      alias_method :add_without_newrelic, :add
-      alias_method :add, :add_with_newrelic
-
-      # Trace as an External/Multiple call if the first request isn't serial.
-      def perform_with_newrelic(&blk)
-        return perform_without_newrelic if first_request_is_serial?
-
-        trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
-          perform_without_newrelic(&blk)
-        end
-      end
-
-      alias_method :perform_without_newrelic, :perform
-      alias_method :perform, :perform_with_newrelic
-
-
-      # Instrument the specified +request+ (a Curl::Easy object)
-      # and set up cross-application tracing if it's enabled.
-      def hook_pending_request(request)
-        wrapped_request, wrapped_response = wrap_request(request)
-
-        segment = NewRelic::Agent::Tracer.start_external_request_segment(
-          library: wrapped_request.type,
-          uri: wrapped_request.uri,
-          procedure: wrapped_request.method
-        )
-
-        segment.add_request_headers wrapped_request
-
-        # install all callbacks
-        unless request._nr_instrumented
-          install_header_callback(request, wrapped_response)
-          install_completion_callback(request, wrapped_response, segment)
-          install_failure_callback(request, wrapped_response, segment)
-          request._nr_instrumented = true
-        end
-      rescue => err
-        NewRelic::Agent.logger.error("Untrapped exception", err)
-      end
-
-
-      # Create request and response adapter objects for the specified +request+
-      # NOTE: Although strange to wrap request and response at once, it works
-      # because curb's callback mechanism updates the instantiated wrappers
-      # during the life-cycle of external request
-      def wrap_request(request)
-        return NewRelic::Agent::HTTPClients::CurbRequest.new(request),
-               NewRelic::Agent::HTTPClients::CurbResponse.new(request)
-      end
-
-      # Install a callback that will record the response headers
-      # to enable CAT linking
-      def install_header_callback(request, wrapped_response)
-        original_callback = request.on_header
-        request._nr_original_on_header = original_callback
-        request._nr_header_str = nil
-        request.on_header do |header_data|
-          if original_callback
-            original_callback.call header_data
-          else
-            wrapped_response.append_header_data header_data
-            header_data.length
-          end
-        end
-      end
-
-      # Install a callback that will finish the trace.
-      def install_completion_callback(request, wrapped_response, segment)
-        original_callback = request.on_complete
-        request._nr_original_on_complete = original_callback
-        request.on_complete do |finished_request|
-          begin
-            segment.process_response_headers wrapped_response
-          ensure
-            segment.finish if segment
-            # Make sure the existing completion callback is run, and restore the
-            # on_complete callback to how it was before.
-            original_callback.call(finished_request) if original_callback
-            remove_instrumentation_callbacks(request)
-          end
-        end
-      end
-
-      # Install a callback that will fire on failures
-      # NOTE:  on_failure is not always called, so we're not always
-      # unhooking the callback.  No harm/no foul in production, but
-      # definitely something to beware of if debugging callback issues
-      # _nr_failure_instrumented exists to prevent infinitely chaining
-      # our on_failure callback hook.
-      def install_failure_callback(request, wrapped_response, segment)
-        return if request._nr_failure_instrumented
-        original_callback = request.on_failure
-        request._nr_original_on_failure = original_callback
-        request.on_failure do |failed_request, error|
-          begin
-            if segment
-              noticible_error = NewRelic::Agent::NoticibleError.new error[0].name, error[-1]
-              segment.notice_error noticible_error
-            end
-          ensure
-            original_callback.call(failed_request, error) if original_callback
-            remove_failure_callback(failed_request)
-          end
-          request._nr_failure_instrumented = true 
-        end
-      end
-
-      # on_failure callbacks cannot be removed in the on_complete
-      # callback where this method is invoked because on_complete
-      # fires before the on_failure!
-      def remove_instrumentation_callbacks(request)
-        request.on_complete(&request._nr_original_on_complete)
-        request.on_header(&request._nr_original_on_header)
-        request._nr_instrumented = false
-      end
-
-      # We execute customer's on_failure callback (if any) and 
-      # uninstall our hook here since the on_complete callback 
-      # fires before the on_failure callback.
-      def remove_failure_callback(request)
-        request.on_failure(&request._nr_original_on_failure)
-        request._nr_failure_instrumented = false
-      end
-
-      private
-
-      def first_request_is_serial?
-        return false unless (first = self.requests.first)
-
-        # Before curb 0.9.8, requests was an array of Curl::Easy
-        # instances.  Starting with 0.9.8, it's a Hash where the
-        # values are Curl::Easy instances.
-        #
-        # So, requests.first will either be an_obj or [a_key, an_obj].
-        # We need to handle either case.
-        #
-        first = first[-1] if first.is_a?(Array)
-
-        first.respond_to?(:_nr_serial) && first._nr_serial
-      end
-
-    end # class Curl::Multi
-
+    if use_prepend?
+      prepend_instrument ::Curl::Easy, NewRelic::Agent::Instrumentation::Curb::Easy::Prepend
+      prepend_instrument ::Curl::Multi, NewRelic::Agent::Instrumentation::Curb::Multi::Prepend
+    else
+      chain_instrument ::NewRelic::Agent::Instrumentation::Curb::Chain
+    end
   end
 end

data/lib/new_relic/agent/instrumentation/delayed_job/chain.rb

@@ -0,0 +1,38 @@
+# 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 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module DelayedJob
+    module Chain
+      def self.instrument!
+        Delayed::Worker.class_eval do
+          include NewRelic::Agent::Instrumentation::DelayedJob
+
+          def initialize_with_new_relic(*args)
+            initialize_with_tracing { initialize_without_new_relic(*args) }
+          end
+    
+          alias initialize_without_new_relic initialize
+          alias initialize initialize_with_new_relic
+    
+    
+          def install_newrelic_job_tracer
+            Delayed::Job.class_eval do
+              include NewRelic::Agent::Instrumentation::DelayedJobTracer
+    
+              alias_method :invoke_job_without_new_relic, :invoke_job
+    
+              def invoke_job(*args, &block)
+                invoke_job_with_tracing { invoke_job_without_new_relic(*args, &block) }
+              end
+    
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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 DelayedJob
+
+        def initialize_with_tracing
+          yield
+          worker_name = case
+                        when self.respond_to?(:name) then self.name
+                        when self.class.respond_to?(:default_name) then self.class.default_name
+                        end
+          NewRelic::DelayedJobInjection.worker_name = worker_name
+  
+          if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
+            !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
+  
+            ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
+            install_newrelic_job_tracer
+            NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
+          else
+            NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
+          end
+        end
+
+      end
+
+      module DelayedJobTracer
+        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+        NR_TRANSACTION_CATEGORY = 'OtherTransaction/DelayedJob'.freeze
+
+        def invoke_job_with_tracing
+          options = {
+            :category => NR_TRANSACTION_CATEGORY,
+            :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
+          }
+
+          perform_action_with_newrelic_trace(options) do
+            yield
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/new_relic/agent/instrumentation/delayed_job/prepend.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
+
+require_relative 'instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module DelayedJob
+        module Prepend
+          include NewRelic::Agent::Instrumentation::DelayedJob
+
+          def initialize(*args)
+            initialize_with_tracing { super }
+          end
+
+          def install_newrelic_job_tracer
+            Delayed::Job.send :prepend, ::NewRelic::Agent::Instrumentation::DelayedJobTracerPrepend
+          end
+        end
+      end
+
+      module DelayedJobTracerPrepend
+        include NewRelic::Agent::Instrumentation::DelayedJobTracer
+
+        def invoke_job(*args, &block)
+          invoke_job_with_tracing { super }
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,9 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
+require_relative 'delayed_job/chain'
+require_relative 'delayed_job/prepend'
+
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
 module NewRelic
@@ -76,11 +79,7 @@ DependencyDetection.defer do
   @name = :delayed_job
 
   depends_on do
-    !NewRelic::Agent.config[:disable_dj]
-  end
-
-  depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Agent.config[:disable_dj]
+    defined?(::Delayed) && defined?(::Delayed::Worker)
   end
 
   executes do
@@ -88,51 +87,10 @@ DependencyDetection.defer do
   end
 
   executes do
-    Delayed::Worker.class_eval do
-
-      def initialize_with_new_relic(*args)
-        initialize_without_new_relic(*args)
-        worker_name = case
-                      when self.respond_to?(:name) then self.name
-                      when self.class.respond_to?(:default_name) then self.class.default_name
-                      end
-        NewRelic::DelayedJobInjection.worker_name = worker_name
-
-        if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
-          !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
-
-          ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
-          install_newrelic_job_tracer
-          NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
-        else
-          NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
-        end
-      end
-
-      alias initialize_without_new_relic initialize
-      alias initialize initialize_with_new_relic
-
-      NR_TRANSACTION_CATEGORY = 'OtherTransaction/DelayedJob'.freeze
-
-      def install_newrelic_job_tracer
-        Delayed::Job.class_eval do
-          include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-          alias_method :invoke_job_without_new_relic, :invoke_job
-
-          def invoke_job(*args, &block)
-            options = {
-              :category => NR_TRANSACTION_CATEGORY,
-              :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
-            }
-
-            perform_action_with_newrelic_trace(options) do
-              invoke_job_without_new_relic(*args, &block)
-            end
-          end
-
-        end
-      end
+    if use_prepend?
+      prepend_instrument ::Delayed::Worker, ::NewRelic::Agent::Instrumentation::DelayedJob::Prepend
+    else
+      chain_instrument ::NewRelic::Agent::Instrumentation::DelayedJob::Chain
     end
   end
 end

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

@@ -5,17 +5,9 @@
 DependencyDetection.defer do
   named :excon
 
-  # We have two ways of instrumenting Excon:
-  # - For newer versions, use the middleware mechanism Excon exposes
-  # - For older versions, monkey-patch Excon::Connection#request
+  # We instrument Excon 0.19.0 and above using the middleware mechanism
   #
   # EXCON_MIN_VERSION is the minimum version we attempt to instrument at all.
-  # EXCON_MIDDLEWARE_MIN_VERSION is the min version we use the newer
-  #   instrumentation for.
-  #
-  # Note that middlewares were added to Excon prior to 0.19, but we don't
-  # use middleware-based instrumentation prior to that version because it didn't
-  # expose a way for middlewares to know about request failures.
   #
   # Why don't we use Excon.defaults[:instrumentor]?
   # While this might seem a perfect fit, it unfortunately isn't suitable in
@@ -25,8 +17,7 @@ DependencyDetection.defer do
   # so we could safely subscribe and not be clobbered by future subscribers,
   # but alas, it does not yet.
 
-  EXCON_MIN_VERSION = Gem::Version.new("0.10.1")
-  EXCON_MIDDLEWARE_MIN_VERSION = Gem::Version.new("0.19.0")
+  EXCON_MIN_VERSION = Gem::Version.new("0.19.0")
 
   depends_on do
     defined?(::Excon) && defined?(::Excon::VERSION)
@@ -45,11 +36,7 @@ DependencyDetection.defer do
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/excon_wrappers'
 
-    if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION
-      install_middleware_excon_instrumentation
-    else
-      install_legacy_excon_instrumentation
-    end
+    install_middleware_excon_instrumentation
   end
 
   def install_middleware_excon_instrumentation
@@ -63,10 +50,5 @@ DependencyDetection.defer do
       ::NewRelic::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
     end
   end
-
-  def install_legacy_excon_instrumentation
-    ::NewRelic::Agent.logger.info 'Installing legacy Excon instrumentation'
-    require 'new_relic/agent/instrumentation/excon/connection'
-    ::Excon::Connection.install_newrelic_instrumentation
-  end
 end
+

data/lib/new_relic/agent/instrumentation/grape/chain.rb

@@ -0,0 +1,25 @@
+# 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 Grape
+    module Chain
+      def self.instrument!
+        Grape::Instrumentation.instrumented_class.class_eval do
+          def call_with_new_relic env
+            begin
+              call_without_new_relic env
+            ensure
+              Grape::Instrumentation.capture_transaction env, self
+            end
+          end
+    
+          alias_method :call_without_new_relic, :call
+          alias_method :call, :call_with_new_relic
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,100 @@
+# 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.
+
+require 'new_relic/agent/parameter_filtering'
+
+module NewRelic::Agent::Instrumentation
+  module Grape
+    module Instrumentation
+
+      extend self
+
+      # Since 1.2.0, the class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is `Grape::API::Instance`
+      # https://github.com/ruby-grape/grape/blob/c20a73ac1e3f3ba1082005ed61bf69452373ba87/UPGRADING.md#upgrading-to--120
+      def instrumented_class
+        defined?(::Grape::API::Instance) ? ::Grape::API::Instance : ::Grape::API
+      end
+
+      def capture_transaction env, context
+        begin
+          endpoint = env[API_ENDPOINT]
+          version = env[API_VERSION]
+
+          api_class = (context.class.respond_to?(:base) && context.class.base) || context.class
+          handle_transaction(endpoint, api_class.name, version)
+        rescue => e
+          ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
+        end
+      end
+
+      def prepare!
+        if defined?(::Grape::VERSION) && Gem::Version.new(::Grape::VERSION) >= Gem::Version.new("0.16.0")
+          send :remove_method, :name_for_transaction_deprecated
+        else
+          send :remove_method, :name_for_transaction
+          send :alias_method, :name_for_transaction, :name_for_transaction_deprecated
+        end
+      end
+
+      API_ENDPOINT   = 'api.endpoint'.freeze
+      API_VERSION    = 'api.version'.freeze
+      FORMAT_REGEX   = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
+      VERSION_REGEX  = /:version(\/|$)/.freeze
+      MIN_VERSION    = Gem::Version.new("0.2.0")
+      PIPE_STRING    = '|'.freeze
+
+      def handle_transaction(endpoint, class_name, version)
+        return unless endpoint && route = endpoint.route
+        name_transaction(route, class_name, version)
+        capture_params(endpoint)
+      end
+
+      def name_transaction(route, class_name, version)
+        txn_name = name_for_transaction(route, class_name, version)
+        segment_name = "Middleware/Grape/#{class_name}/call"
+        NewRelic::Agent::Transaction.set_default_transaction_name(txn_name, :grape)
+        txn = NewRelic::Agent::Transaction.tl_current
+        txn.segments.last.name = segment_name
+      end
+
+      def name_for_transaction(route, class_name, version)
+        action_name = route.path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
+        method_name = route.request_method
+        version ||= route.version
+
+        # defaulting does not set rack.env['api.version'] and route.version may return Array
+        #
+        version = version.join(PIPE_STRING) if Array === version
+
+        if version
+          action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
+          "#{class_name}-#{version}#{action_name} (#{method_name})"
+        else
+          "#{class_name}#{action_name} (#{method_name})"
+        end
+      end
+
+      def name_for_transaction_deprecated(route, class_name, version)
+        action_name = route.route_path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
+        method_name = route.route_method
+        version ||= route.route_version
+        if version
+          action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
+          "#{class_name}-#{version}#{action_name} (#{method_name})"
+        else
+          "#{class_name}#{action_name} (#{method_name})"
+        end
+      end
+
+      def capture_params(endpoint)
+        txn = ::NewRelic::Agent::Transaction.tl_current
+        env = endpoint.request.env
+        params = ::NewRelic::Agent::ParameterFiltering::apply_filters(env, endpoint.params)
+        params.delete("route_info")
+        txn.filtered_params = params
+        txn.merge_request_parameters(params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# 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 Grape
+    module Prepend
+      def call env
+        begin
+          super env
+        ensure
+          Grape::Instrumentation.capture_transaction env, self
+        end
+      end
+    end
+  end
+end