newrelic_rpm 6.15.0 → 7.2.0

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

@@ -65,7 +65,8 @@ DependencyDetection.defer do
   end
 
   def install_legacy_excon_instrumentation
-    ::NewRelic::Agent.logger.info 'Installing legacy Excon instrumentation'
+    ::NewRelic::Agent::Deprecator.deprecate :install_legacy_excon_instrumentation, :install_middleware_excon_instrumentation, "8.0.0"
+    ::NewRelic::Agent.logger.warn 'Installing deprecated legacy Excon instrumentation. This instrumentation will be removed in a future release. Update Excon version to > 0.19.0 for updated instrumentation'
     require 'new_relic/agent/instrumentation/excon/connection'
     ::Excon::Connection.install_newrelic_instrumentation
   end

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

@@ -2,90 +2,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.
 
-require 'new_relic/agent/parameter_filtering'
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module GrapeInstrumentation
-        extend self
-
-        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"
-          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 = Transaction.tl_current
-          env = endpoint.request.env
-          params = ParameterFiltering::apply_filters(env, endpoint.params)
-          params.delete("route_info")
-          txn.filtered_params = params
-          txn.merge_request_parameters(params)
-        end
-      end
-    end
-  end
-end
+require_relative 'grape/instrumentation'
+require_relative 'grape/chain'
+require_relative 'grape/prepend'
 
 DependencyDetection.defer do
   # Why not just :grape? newrelic-grape used that name already, and while we're
   # not shipping yet, overloading the name interferes with the plugin.
   named :grape_instrumentation
-
-  depends_on do
-    ::NewRelic::Agent.config[:disable_grape] == false
-  end
-
+  configure_with :grape
+  
   depends_on do
     defined?(::Grape::VERSION) &&
-      Gem::Version.new(::Grape::VERSION) >= ::NewRelic::Agent::Instrumentation::GrapeInstrumentation::MIN_VERSION
+      Gem::Version.new(::Grape::VERSION) >= ::NewRelic::Agent::Instrumentation::Grape::Instrumentation::MIN_VERSION
   end
 
   depends_on do
@@ -103,43 +32,14 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing New Relic supported Grape instrumentation'
-    instrument_call
-  end
+    ::NewRelic::Agent::Instrumentation::Grape::Instrumentation.prepare!
 
-  def instrument_call
-    if defined?(Grape::VERSION) && Gem::Version.new(::Grape::VERSION) >= Gem::Version.new("0.16.0")
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction_deprecated
-    else
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :alias_method, :name_for_transaction, :name_for_transaction_deprecated
-    end
-
-    # 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
-    grape_api_class = defined?(Grape::API::Instance) ? ::Grape::API::Instance : ::Grape::API
-
-    grape_api_class.class_eval do
-      def call_with_new_relic(env)
-        begin
-          response = call_without_new_relic(env)
-        ensure
-          begin
-            endpoint = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
-            version = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_VERSION]
-
-            api_class = (self.class.respond_to?(:base) && self.class.base) || self.class
-            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, api_class.name, version)
-          rescue => e
-            ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
-          end
-        end
-
-        response
-      end
-
-      alias_method :call_without_new_relic, :call
-      alias_method :call, :call_with_new_relic
+    if use_prepend?
+      instrumented_class = ::NewRelic::Agent::Instrumentation::Grape::Instrumentation.instrumented_class
+      prepend_instrument instrumented_class, ::NewRelic::Agent::Instrumentation::Grape::Prepend
+    else 
+      chain_instrument ::NewRelic::Agent::Instrumentation::Grape::Chain
     end
   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

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

@@ -2,6 +2,10 @@
 # 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 'httpclient/instrumentation'
+require_relative 'httpclient/chain'
+require_relative 'httpclient/prepend'
+
 DependencyDetection.defer do
   named :httpclient
 
@@ -25,36 +29,10 @@ DependencyDetection.defer do
   end
 
   executes do
-    class HTTPClient
-      def do_get_block_with_newrelic(req, proxy, conn, &block)
-        wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(req)
-        segment = NewRelic::Agent::Tracer.start_external_request_segment(
-          library: wrapped_request.type,
-          uri: wrapped_request.uri,
-          procedure: wrapped_request.method
-        )
-
-        begin
-          response = nil
-          segment.add_request_headers wrapped_request
-
-          NewRelic::Agent::Tracer.capture_segment_error segment do
-            do_get_block_without_newrelic(req, proxy, conn, &block)
-          end
-          response = conn.pop
-          conn.push response
-
-          wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
-          segment.process_response_headers wrapped_response
-
-          response
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias do_get_block_without_newrelic do_get_block
-      alias do_get_block do_get_block_with_newrelic
+    if use_prepend?
+      prepend_instrument ::HTTPClient, NewRelic::Agent::Instrumentation::HTTPClient::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::HTTPClient::Chain
     end
   end
 end