newrelic_rpm 6.13.1 → 6.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97813a208eb3ad21826b8069ad1978523f4fc24d1c823e2ef887a33242f8dc93
-  data.tar.gz: 8ccc2df94bcffa988b31ffb8f4015b2ce6ab7997c8690386e3ef6a77fcdefe6b
+  metadata.gz: 39bec77198864a8dbc979a6a3591345b367f8b6294a239ec09b489935cabc518
+  data.tar.gz: 79a25011a511ba59df1967493bfc832245c9221f130cb607dd1af798173f7317
 SHA512:
-  metadata.gz: 609270a7843fc1b63aef90f1e5892532f8e28e2bfbbbb077e7b3024851931ca62f68ef18bc6c2c1f5abe35db5f01d6c5d438553a7d0761a07f08d40d341604af
-  data.tar.gz: 44413974581e5334c04ed78d8c6802d0ffef07ec7fbfc20e785cabf6bb45b3331e01f6499d70da57aee368e69e50c1c0986d672b4c68760f1c4b09d55da4faa6
+  metadata.gz: 18e3a2321e17851bef4b4baa84358a81ff5f0b4870f9bbc35bd5e2d5daea4a02366649e3cbcc1735cfe0aaeb337caecb87c2e189c0703dda2325b55945108421
+  data.tar.gz: 6de78ac450e087b4a7b10ffbf181be79e9451d8ac9c7bfd0d5af5bad6ef98a004aff6fe987d4231fe02874d253a8d45c847419bfbe21c2103dcb86e97070f1b5

data/.gitignore

@@ -1,3 +1,4 @@
+.ruby-version
 Gemfile.lock
 Guard*
 .DS\_Store

data/CHANGELOG.md

@@ -1,5 +1,60 @@
 # New Relic Ruby Agent Release Notes #
 
+  ## v6.14.0
+
+  * **Bugfix: Method tracers no longer cloning arguments**
+  
+    Previously, when calling add_method_tracer with certain combination of arguments, it would lead to the wrapped method's arguments
+    being cloned rather than passed to the original method for manipulation as intended.  This has been fixed.
+
+  * **Bugfix: Delayed Job instrumentation fixed for Ruby 2.7+**
+
+    Previously, the agent was erroneousy separating positional and keyword arguments on the instrumented method calls into
+    Delayed Job's library.  The led to Delayed job not auto-instrumenting correctly and has been fixed.
+
+  * **Bugfix: Ruby 2.7+ methods sometimes erroneously attributed compiler warnings to the Agent's `add_method_tracer`**
+  
+    The specific edge cases presented are now fixed by this release of the agent.  There are still some known corner-cases
+    that will be resolved with upcoming changes in next major release of the Agent.  If you encounter a problem with adding 
+    method tracers and compiler warnings raised, please continue to submit small repoducible examples.
+
+  * **Bugfix: Ruby 2.7+ fix for keyword arguments on Rack apps is unnecessary and removed**
+
+    A common fix for positional and keyword arguments for method parameters was implemented where it was not needed and 
+    led to RackApps getting extra arguments converted to keyword arguments rather than Hash when it expected one.  This 
+    Ruby 2.7+ change was reverted so that Rack apps behave correctly for Ruby >= 2.7.
+
+  * **Feature: captures incoming and outgoing request headers for distributed tracing**
+
+    HTTP request headers will be logged when log level is at least debug level.  Similarly, request headers 
+    for exchanges with New Relic servers are now audit logged when audit logging is enabled.
+    
+  * **Bugfix: `newrelic.yml.erb` added to the configuration search path**
+
+    Previously, when a user specifies a `newrelic.yml.erb` and no `newrelic.yml` file, the agent fails to find
+    the `.erb` file because it was not in the list of files searched at startup.  The Ruby agent has long supported this as a
+    means of configuring the agent programatically.  The `newrelic.yml.erb` filename is restored to the search
+    path and will be utilized if present.  NOTE:  `newrelic.yml` still takes precedence over `newrelic.yml.erb`  If found,
+    the `.yml` file is used instead of the `.erb` file.  Search directories and order of traversal remain unchanged.
+
+  * **Bugfix: dependency detection of Redis now works without raising an exception**
+    
+    Previously, when detecting if Redis was available to instrument, the dependency detection would fail with an Exception raised
+    (with side effect of not attempting to instrument Redis).  This is now fixed with a better dependency check that resolves falsly without raising an `Exception`.
+
+  * **Bugfix: Gracefully handles NilClass as a Middleware Class when instrumenting**
+
+    Previously, if a NilClass is passed as the Middleware Class to instrument when processing the middleware stack,
+    the agent would fail to fully load and instrument the middleware stack.  This fix gracefully skips over nil classes.
+
+  * **Memory Sampler updated to recognize macOS Big Sur**
+
+    Previously, the agent was unable to recognize the platform macOS Big Sur in the memory sampler, resulting in an error being logged. The memory sampler is now able to recognize Big Sur. 
+
+  * **Prepend implementation of Net::HTTP instrumentation available**
+    
+    There is now a config option (`prepend_net_instrumentation`) that will enable the agent to use prepend while instrumenting Net::HTTP. This option is set to true by default.
+    
   ## v6.13.1
 
   * **Bugfix: obfuscating URLs to external services no longer modifying original URI**

data/lib/new_relic/agent/audit_logger.rb

@@ -26,6 +26,16 @@ module NewRelic
         !@log.nil?
       end
 
+      def log_request_headers(uri, headers)
+        return unless enabled? && allowed_endpoint?(uri)
+        @log.info("REQUEST HEADERS: #{headers}")
+      rescue StandardError, SystemStackError, SystemCallError => e
+        ::NewRelic::Agent.logger.warn("Failed writing request headers to audit log", e)
+      rescue Exception => e
+        ::NewRelic::Agent.logger.warn("Failed writing request headers to audit log with exception. Re-raising in case of interrupt.", e)
+        raise
+      end
+
       def log_request(uri, data, marshaller)
         return unless enabled? && allowed_endpoint?(uri)
 

data/lib/new_relic/agent/configuration/default_source.rb

@@ -48,23 +48,30 @@ module NewRelic
           Proc.new {
             paths = [
               File.join("config","newrelic.yml"),
-              File.join("newrelic.yml")
+              File.join("newrelic.yml"),
+              File.join("config","newrelic.yml.erb"),
+              File.join("newrelic.yml.erb")
             ]
 
             if NewRelic::Control.instance.root
               paths << File.join(NewRelic::Control.instance.root, "config", "newrelic.yml")
               paths << File.join(NewRelic::Control.instance.root, "newrelic.yml")
+              paths << File.join(NewRelic::Control.instance.root, "config", "newrelic.yml.erb")
+              paths << File.join(NewRelic::Control.instance.root, "newrelic.yml.erb")
             end
 
             if ENV["HOME"]
               paths << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
               paths << File.join(ENV["HOME"], "newrelic.yml")
+              paths << File.join(ENV["HOME"], ".newrelic", "newrelic.yml.erb")
+              paths << File.join(ENV["HOME"], "newrelic.yml.erb")
             end
 
             # If we're packaged for warbler, we can tell from GEM_HOME
             if ENV["GEM_HOME"] && ENV["GEM_HOME"].end_with?(".jar!")
               app_name = File.basename(ENV["GEM_HOME"], ".jar!")
               paths << File.join(ENV["GEM_HOME"], app_name, "config", "newrelic.yml")
+              paths << File.join(ENV["GEM_HOME"], app_name, "config", "newrelic.yml.erb")
             end
 
             paths
@@ -823,6 +830,13 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'If <code>true</code>, uses Module.prepend rather than alias_method for ActiveRecord instrumentation.'
         },
+        :prepend_net_instrumentation => {
+          :default => true,
+          :public => true,
+          :type => Boolean,
+          :allowed_from_server => false,
+          :description => 'If <code>true</code>, uses Module.prepend rather than alias_method for Net::HTTP instrumentation.'
+        },
         :disable_data_mapper => {
           :default => false,
           :public => true,

data/lib/new_relic/agent/distributed_tracing/cross_app_tracing.rb

@@ -52,14 +52,14 @@ module NewRelic
         result
       end
 
-      def insert_cross_app_header request
+      def insert_cross_app_header headers
         return unless CrossAppTracing.cross_app_enabled?
         @is_cross_app_caller = true
         txn_guid  = transaction.guid
         trip_id   = cat_trip_id
         path_hash = cat_path_hash
 
-        insert_request_headers request, txn_guid, trip_id, path_hash
+        insert_request_headers headers, txn_guid, trip_id, path_hash
       end
 
       def add_message_cat_headers headers

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

@@ -23,12 +23,11 @@ module NewRelic
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload)
           if segment = pop_segment(id)
-
-          if exception = exception_object(payload)
-            segment.notice_error exception
-          end
+            if exception = exception_object(payload)
+              segment.notice_error exception
+            end
             segment.finish
           end
         rescue => e

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

@@ -90,43 +90,22 @@ DependencyDetection.defer do
   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
+      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
 

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

@@ -27,18 +27,10 @@ module NewRelic
             @middleware_class = middleware_class
           end
 
-          if RUBY_VERSION < "2.7.0"
-            def new(*args, &blk)
-              middleware_instance = @middleware_class.new(*args, &blk)
-              MiddlewareProxy.wrap(middleware_instance)
-            end
-          else
-            def new(*args, **kwargs, &blk)
-              middleware_instance = @middleware_class.new(*args, **kwargs, &blk)
-              MiddlewareProxy.wrap(middleware_instance)
-            end
+          def new(*args, &blk)
+            middleware_instance = @middleware_class.new(*args, &blk)
+            MiddlewareProxy.wrap(middleware_instance)
           end
-
         end
 
         def self.is_sinatra_app?(target)

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

@@ -16,72 +16,79 @@ DependencyDetection.defer do
   end
 
   executes do
-    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)
+    if ::NewRelic::Agent.config[:prepend_net_instrumentation]
+      if RUBY_VERSION < "2.1.0"
+        ::Net::HTTP.send(:prepend, ::NewRelic::Agent::Instrumentation::NetPrepend)
+      else
+        ::Net::HTTP.prepend ::NewRelic::Agent::Instrumentation::NetPrepend
+      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
-  
-            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  
+        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
               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
-    
+  
+        alias request_without_newrelic_trace request
+        alias request request_with_newrelic_trace
       end
-
-
-      alias request_without_newrelic_trace request
-      alias request request_with_newrelic_trace
     end
+
   end
 end

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

@@ -0,0 +1,72 @@
+# 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 
+  module Agent 
+    module Instrumentation
+      module NetPrepend
+
+        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
+            )
+    
+            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)
+  
+            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
+        end
+      end
+    end
+  end
+end