newrelic_rpm 6.14.0 → 6.15.0

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

@@ -32,48 +32,30 @@ DependencyDetection.defer do
 
       # We have to hook these three methods separately, as they don't use
       # Curl::Easy#http
-      if RUBY_VERSION < "2.7.0"
-        def http_head_with_newrelic(*args, &blk)
-          self._nr_http_verb = :HEAD
-          http_head_without_newrelic(*args, &blk)
-        end
-      else
-        def http_head_with_newrelic(*args, **kwargs, &blk)
-          self._nr_http_verb = :HEAD
-          http_head_without_newrelic(*args, **kwargs, &blk)
-        end
+      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
 
-      if RUBY_VERSION < "2.7.0"
-        def http_post_with_newrelic(*args, &blk)
-          self._nr_http_verb = :POST
-          http_post_without_newrelic(*args, &blk)
-        end
-      else
-        def http_post_with_newrelic(*args, **kwargs, &blk)
-          self._nr_http_verb = :POST
-          http_post_without_newrelic(*args, **kwargs, &blk)
-        end
+      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
 
-      if RUBY_VERSION < "2.7.0"
-        def http_put_with_newrelic(*args, &blk)
-          self._nr_http_verb = :PUT
-          http_put_without_newrelic(*args, &blk)
-        end
-      else
-        def http_put_with_newrelic(*args, **kwargs, &blk)
-          self._nr_http_verb = :PUT
-          http_put_without_newrelic(*args, **kwargs, &blk)
-        end
+      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
 

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

@@ -120,27 +120,14 @@ DependencyDetection.defer do
 
           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
+          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
 

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

@@ -15,8 +15,14 @@ DependencyDetection.defer do
     require 'new_relic/agent/http_clients/net_http_wrappers'
   end
 
+  def monkey_patched
+    defined?(::Airbrake) || 
+    defined?(::Rack::MiniProfiler) ||
+    source_location_for(Net::HTTP, "request") =~ /airbrake|profiler/i
+  end
+
   executes do
-    if ::NewRelic::Agent.config[:prepend_net_instrumentation]
+    if ::NewRelic::Agent.config[:prepend_net_instrumentation] && !monkey_patched
       if RUBY_VERSION < "2.1.0"
         ::Net::HTTP.send(:prepend, ::NewRelic::Agent::Instrumentation::NetPrepend)
       else
@@ -24,66 +30,36 @@ DependencyDetection.defer do
       end
     else 
       NewRelic::Agent.record_metric("Supportability/Instrumentation/NetHTTP/MethodChaining", 0.0)
+
       class Net::HTTP
-        if RUBY_VERSION < "2.7.0"
-          def request_with_newrelic_trace(request, *args, &block)
-            wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
-    
-            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
-    
-              # RUBY-1244 Disable further tracing in request to avoid double
-              # counting if connection wasn't started (which calls request again).
-              NewRelic::Agent.disable_all_tracing do
-                response = NewRelic::Agent::Tracer.capture_segment_error segment do
-                  request_without_newrelic_trace(request, *args, &block)
-                end
-              end
-    
-              wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
-              segment.process_response_headers wrapped_response
-              response
-            ensure
-              segment.finish
-            end
-          end  
-        else
-          def request_with_newrelic_trace(request, *args, **kwargs, &block)
-            wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
-    
-            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
-    
-              # RUBY-1244 Disable further tracing in request to avoid double
-              # counting if connection wasn't started (which calls request again).
-              NewRelic::Agent.disable_all_tracing do
-                response = NewRelic::Agent::Tracer.capture_segment_error segment do
-                  request_without_newrelic_trace(request, *args, **kwargs, &block)
-                end
+        def request_with_newrelic_trace(request, *args, &block)
+          wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+  
+          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
+  
+            # RUBY-1244 Disable further tracing in request to avoid double
+            # counting if connection wasn't started (which calls request again).
+            NewRelic::Agent.disable_all_tracing do
+              response = NewRelic::Agent::Tracer.capture_segment_error segment do
+                request_without_newrelic_trace(request, *args, &block)
               end
-    
-              wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
-              segment.process_response_headers wrapped_response
-              response
-            ensure
-              segment.finish
             end
+  
+            wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
+            segment.process_response_headers wrapped_response
+            response
+          ensure
+            segment.finish
           end
-        end
+        end  
   
         alias request_without_newrelic_trace request
         alias request request_with_newrelic_trace

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

@@ -6,64 +6,32 @@ module NewRelic
   module Agent 
     module Instrumentation
       module NetPrepend
+        def request(request, *args, &block)
+          wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
-        if RUBY_VERSION < "2.7.0"
-          def request(request, *args, &block)
-            wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+          segment = NewRelic::Agent::Tracer.start_external_request_segment(
+            library: wrapped_request.type,
+            uri: wrapped_request.uri,
+            procedure: wrapped_request.method
+          )
   
-            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
-    
-              # RUBY-1244 Disable further tracing in request to avoid double
-              # counting if connection wasn't started (which calls request again).
-              NewRelic::Agent.disable_all_tracing do
-                response = NewRelic::Agent::Tracer.capture_segment_error segment do
-                  super
-                end
-              end
-    
-              wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
-              segment.process_response_headers wrapped_response
-              response
-            ensure
-              segment.finish
-            end
-          end
-        else
-          def request(request, *args, **kwargs, &block)
-            wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+          begin
+            response = nil
+            segment.add_request_headers wrapped_request
   
-            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
-    
-              # RUBY-1244 Disable further tracing in request to avoid double
-              # counting if connection wasn't started (which calls request again).
-              NewRelic::Agent.disable_all_tracing do
-                response = NewRelic::Agent::Tracer.capture_segment_error segment do
-                  super
-                end
+            # RUBY-1244 Disable further tracing in request to avoid double
+            # counting if connection wasn't started (which calls request again).
+            NewRelic::Agent.disable_all_tracing do
+              response = NewRelic::Agent::Tracer.capture_segment_error segment do
+                super
               end
-    
-              wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
-              segment.process_response_headers wrapped_response
-              response
-            ensure
-              segment.finish
             end
+  
+            wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
+            segment.process_response_headers wrapped_response
+            response
+          ensure
+            segment.finish
           end
         end
       end

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

@@ -44,46 +44,24 @@ module NewRelic
     module Instrumentation
       module Padrino
 
-        if RUBY_VERSION < "2.7.0"
-          def invoke_route_with_newrelic(*args, &block)
-            begin
-              env["newrelic.last_route"] = args[0].original_path
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
-            end
-  
-            begin
-              txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
-              unless txn_name.nil?
-                ::NewRelic::Agent::Transaction.set_default_transaction_name(
-                  "#{self.class.name}/#{txn_name}", :sinatra)
-              end
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
-            end
-  
-            invoke_route_without_newrelic(*args, &block)
+        def invoke_route_with_newrelic(*args, &block)
+          begin
+            env["newrelic.last_route"] = args[0].original_path
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
           end
-        else
-          def invoke_route_with_newrelic(*args, **kwargs, &block)
-            begin
-              env["newrelic.last_route"] = args[0].original_path
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
-            end
-  
-            begin
-              txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
-              unless txn_name.nil?
-                ::NewRelic::Agent::Transaction.set_default_transaction_name(
-                  "#{self.class.name}/#{txn_name}", :sinatra)
-              end
-            rescue => e
-              ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
+
+          begin
+            txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
+            unless txn_name.nil?
+              ::NewRelic::Agent::Transaction.set_default_transaction_name(
+                "#{self.class.name}/#{txn_name}", :sinatra)
             end
-  
-            invoke_route_without_newrelic(*args, **kwargs, &block)
+          rescue => e
+            ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
           end
+
+          invoke_route_without_newrelic(*args, &block)
         end
 
       end

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

@@ -82,23 +82,12 @@ module NewRelic
 
       module RackBuilder
 
-        if RUBY_VERSION < "2.7.0"
-          def run_with_newrelic(app, *args)
-            if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
-              wrapped_app = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-              run_without_newrelic(wrapped_app, *args)
-            else
-              run_without_newrelic(app, *args)
-            end
-          end
-        else
-          def run_with_newrelic(app, *args, **kwargs)
-            if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
-              wrapped_app = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-              run_without_newrelic(wrapped_app, *args, **kwargs)
-            else
-              run_without_newrelic(app, *args, **kwargs)
-            end
+        def run_with_newrelic(app, *args)
+          if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+            wrapped_app = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+            run_without_newrelic(wrapped_app, *args)
+          else
+            run_without_newrelic(app, *args)
           end
         end
 

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

@@ -24,51 +24,26 @@ DependencyDetection.defer do
       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
 
-        if RUBY_VERSION < "2.7.0"
-          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
+          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
-        else
-          def invoke(*args, **kwargs)
-            unless NewRelic::Agent::Instrumentation::RakeInstrumentation.should_trace? name
-              return invoke_without_newrelic(*args, **kwargs)
-            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, **kwargs)
-            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, **kwargs)
-            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
@@ -112,20 +87,11 @@ module NewRelic
 
           task.instance_variable_set(:@__newrelic_instrumented_execute, true)
           task.instance_eval do
-            if RUBY_VERSION < "2.7.0"
-              def execute(*args, &block)
-                NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
-                  super
-                end
-              end
-            else
-              def execute(*args, **kwargs, &block)
-                NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
-                  super
-                end
+            def execute(*args, &block)
+              NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/#{self.name}") do
+                super
               end
             end
-
           end
 
           instrument_execute_on_prereqs(task)