newrelic_rpm 6.12.0.367 → 7.0.0

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

@@ -0,0 +1,63 @@
+# 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 Curb
+        module Easy
+          module Prepend
+            include NewRelic::Agent::Instrumentation::Curb::Easy
+
+            def http_head(*args, &blk)
+              http_head_with_tracing { super }
+            end
+      
+            def http_post(*args, &blk)
+              http_post_with_tracing { super }
+            end
+      
+            def http_put(*args, &blk)
+              http_put_with_tracing { super }
+            end
+      
+            def http verb
+              http_with_tracing(verb) { super }
+            end
+      
+            def perform
+              perform_with_tracing { super }
+            end
+      
+            def method verb
+              method_with_tracing { super }
+            end
+      
+            def header_str
+              header_str_with_tracing { super }
+            end
+          end
+        end
+
+        module Multi
+          module Prepend
+            include NewRelic::Agent::Instrumentation::Curb::Multi
+      
+            def add(curl)
+              add_with_tracing(curl) { super }
+            end
+
+            def perform(&blk)
+              perform_with_tracing { super }
+            end
+      
+          end
+        end
+      end
+    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,85 +87,10 @@ DependencyDetection.defer do
   end
 
   executes do
-    Delayed::Worker.class_eval do
-
-      if RUBY_VERSION < "2.7.0"
-        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
-      else
-        def initialize_with_new_relic(*args, **kwargs)
-          initialize_without_new_relic(*args, **kwargs)
-          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
-
-      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
-
-          if RUBY_VERSION < "2.7.0"
-            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
-          else
-            def invoke_job(*args, **kwargs, &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, **kwargs, &block)
-              end
-            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