newrelic_rpm 6.14.0 → 6.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39bec77198864a8dbc979a6a3591345b367f8b6294a239ec09b489935cabc518
-  data.tar.gz: 79a25011a511ba59df1967493bfc832245c9221f130cb607dd1af798173f7317
+  metadata.gz: 59fdb006789ae2f1cb776c15084ad1bc7f854abf000573fd11dd2c14882b4273
+  data.tar.gz: 7b8d00cdaa547832fb34c1f76a697b694ff28c9a74be046545e7d3b0866d97e6
 SHA512:
-  metadata.gz: 18e3a2321e17851bef4b4baa84358a81ff5f0b4870f9bbc35bd5e2d5daea4a02366649e3cbcc1735cfe0aaeb337caecb87c2e189c0703dda2325b55945108421
-  data.tar.gz: 6de78ac450e087b4a7b10ffbf181be79e9451d8ac9c7bfd0d5af5bad6ef98a004aff6fe987d4231fe02874d253a8d45c847419bfbe21c2103dcb86e97070f1b5
+  metadata.gz: 5cadb8ca1d02feadc30a85871d1e8cd6c24064bfc3b1bed98680573bb4c29075e07447f4290dfc360d9607c1ff3a5433d0c36be9eaeae515c725547424ee92cc
+  data.tar.gz: c3901a54a577cdab2159ee6a93bf4bd6acf82d6629d4d4ba99c4565d7155efc7d653387f9fcee8cd246d19cecfe662b60bd63f05cbf19d38194e0b6d9d6ce0b9

data/CHANGELOG.md

@@ -1,11 +1,61 @@
 # New Relic Ruby Agent Release Notes #
 
+  ## v6.15.0
+
+  * **Official Ruby 3.0 support**
+    
+    The ruby agent has been verified to run on ruby 3.0.0
+
+  * **Added support for Rails 6.1**
+
+    The ruby agent has been verified to run with Rails 6.1
+    Special thanks to @hasghari for setting this up!
+
+  * **Added support for Sidekiq 6.0, 6.1**
+
+    The ruby agent has been verified to run with both 6.0 and 6.1 versions of sidekiq
+
+  * **Bugfix: No longer overwrites sidekiq trace data**
+
+    Distributed traing data is now added to the job trace info rather than overwriting the existing data.
+
+  * **Bugfix: Fixes cases where errors are reported for spans with no other attributes**
+
+    Previously, in cases where a span does not have any agent/custom attributes on it, but an error
+    is noticed and recorded against the span, a `FrozenError: can't modify frozen Hash` is thrown.
+    This is now fixed and errors are now correctly recorded against such span events.
+
+  * **Bugfix: `DistributedTracing.insert_distributed_trace_headers` Supportability metric now recorded**
+    
+    Previously, API calls to `DistributedTracing.insert_distributed_trace_headers` would lead to an exception
+    about the missing supportability metric rather than flowing through the API implementation as intended.
+    This would potentially lead to broken distributed traces as the trace headers were not inserted on the API call.
+    `DistributedTracing.insert_distributed_trace_headers` now correctly records the supportability metric and
+    inserts the distributed trace headers as intended.
+
+  * **Bugfix: child completions after parent completes sometimes throws exception attempting to access nil parent**
+
+    In scenarios where the child segment/span is completing after the parent in jRuby, the parent may have already
+    been freed and no longer accessible.  This would lead to attempting to calll `descendant_complete` on a Nil
+    object.  This is fixed to protect against calling the `descendant_complete` in such cases.
+    
+  * **Feature: implements `force_install_exit_handler` config flag**
+    
+    The `force_install_exit_handler` configuration flag allows an application to instruct the agent to install it's 
+    graceful shutdown exit handler, which will send any locally cached data to the New Relic collector prior to the 
+    application shutting down.  This useful for when the primary framework has an embedded Sinatra application that 
+    is otherwise detected and skips installing the exit hook for graceful shutdowns.
+
+  * **Default prepend_net_instrumentation to false**
+
+    Previously, `prepend_net_instrumentation` defaulted to true. However, many gems are still using monkey patching on Net::HTTP, which causes compatibility issues with using prepend. Defaulting this to false minimizes instances of 
+    unexpected compatibilty issues.
+    
   ## 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.
+    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+**
 

data/lib/new_relic/agent.rb

@@ -46,6 +46,7 @@ module NewRelic
     require 'new_relic/agent/error_collector'
     require 'new_relic/agent/sampler'
     require 'new_relic/agent/database'
+    require 'new_relic/agent/database_adapter'
     require 'new_relic/agent/datastores'
     require 'new_relic/agent/pipe_channel_manager'
     require 'new_relic/agent/configuration'

data/lib/new_relic/agent/agent.rb

@@ -395,10 +395,8 @@ module NewRelic
           end
 
           def should_install_exit_handler?
-            (
-              Agent.config[:send_data_on_exit]  &&
-              !sinatra_classic_app?
-            )
+            return false unless Agent.config[:send_data_on_exit]
+            !sinatra_classic_app? || Agent.config[:force_install_exit_handler]
           end
 
           def install_exit_handler

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

@@ -703,6 +703,18 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'Enable or disable retrying failed connections to the New Relic data collection service.'
         },
+        :force_install_exit_handler => {
+          :default => false,
+          :public => true,
+          :type => Boolean,
+          :allowed_from_server => false,
+          :description => 'Forces the exit handler that sends all cached data to collector ' \
+            'before shuttng down to be installed regardless of detecting scenarios where it generally should not be. ' \
+            'Known use-case for this option is where Sinatra is running as an embedded service within another framework ' \
+            'and the agent is detecting the Sinatra app and skipping the at_exit handler as a result. Sinatra classically ' \
+            'runs the entire application in an at_exit block and would otherwise misbehave if the Agent\'s at_exit handler ' \
+            'is also installed in those circumstances.  Note: `send_data_on_exit` should also be set to `true` in  tandem with this setting.'
+        },
         :force_reconnect => {
           :default => false,
           :public => false,
@@ -831,7 +843,7 @@ module NewRelic
           :description => 'If <code>true</code>, uses Module.prepend rather than alias_method for ActiveRecord instrumentation.'
         },
         :prepend_net_instrumentation => {
-          :default => true,
+          :default => false,
           :public => true,
           :type => Boolean,
           :allowed_from_server => false,

data/lib/new_relic/agent/database_adapter.rb

@@ -0,0 +1,33 @@
+# 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
+    class DatabaseAdapter
+      VERSIONS = {
+        '6.1.0' => proc { ActiveRecord::Base.connection_db_config.configuration_hash[:adapter] },
+        '4.0.0' => proc { ActiveRecord::Base.connection_config[:adapter] },
+        '3.0.0' => proc { |env| ActiveRecord::Base.configurations[env]['adapter'] }
+      }
+
+      def self.value
+        return unless defined? ActiveRecord::Base
+        new(::NewRelic::Control.instance.env, ActiveRecord::VERSION::STRING).value
+      end
+
+      attr_reader :env, :version
+
+      def initialize(env, version)
+        @env = env
+        @version = Gem::Version.new(version)
+      end
+
+      def value
+        match = VERSIONS.keys.find { |key| version >= Gem::Version.new(key) }
+        return unless match
+        VERSIONS[match].call(env)
+      end
+    end
+  end
+end

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

@@ -20,37 +20,19 @@ module NewRelic
           ::ActiveRecord::Base.class_eval do
             alias_method :save_without_newrelic, :save
             
-            if RUBY_VERSION < "2.7.0"
-              def save(*args, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-                  save_without_newrelic(*args, &blk)
-                end
-              end
-            else
-              def save(*args, **kwargs, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-                  save_without_newrelic(*args, **kwargs, &blk)
-                end
+            def save(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_newrelic(*args, &blk)
               end
-
             end
 
             alias_method :save_without_newrelic!, :save!
 
-            if RUBY_VERSION < "2.7.0"
-              def save!(*args, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-                  save_without_newrelic!(*args, &blk)
-                end
-              end
-            else
-              def save!(*args, **kwargs, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-                  save_without_newrelic!(*args, **kwargs, &blk)
-                end
+            def save!(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_newrelic!(*args, &blk)
               end
             end
-
           end
         end
 
@@ -58,17 +40,9 @@ module NewRelic
           ::ActiveRecord::Relation.class_eval do
             alias_method :update_all_without_newrelic, :update_all
 
-            if RUBY_VERSION < "2.7.0"
-              def update_all(*args, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                  update_all_without_newrelic(*args, &blk)
-                end
-              end
-            else
-              def update_all(*args, **kwargs, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                  update_all_without_newrelic(*args, **kwargs, &blk)
-                end
+            def update_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                update_all_without_newrelic(*args, &blk)
               end
             end
             
@@ -90,52 +64,31 @@ module NewRelic
 
             alias_method :destroy_all_without_newrelic, :destroy_all
 
-            if RUBY_VERSION < "2.7.0"
-              def destroy_all(*args, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                  destroy_all_without_newrelic(*args, &blk)
-                end
-              end
-            else
-              def destroy_all(*args, **kwargs, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                  destroy_all_without_newrelic(*args, **kwargs, &blk)
-                end
+            def destroy_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                destroy_all_without_newrelic(*args, &blk)
               end
             end
 
+
             alias_method :calculate_without_newrelic, :calculate
 
-            if RUBY_VERSION < "2.7.0"
-              def calculate(*args, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                  calculate_without_newrelic(*args, &blk)
-                end
-              end
-            else
-              def calculate(*args, **kwargs, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                  calculate_without_newrelic(*args, **kwargs, &blk)
-                end
+            def calculate(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                calculate_without_newrelic(*args, &blk)
               end
             end
 
+
             if method_defined?(:pluck)
               alias_method :pluck_without_newrelic, :pluck
 
-              if RUBY_VERSION < "2.7.0"
-                def pluck(*args, &blk)
-                  ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                    pluck_without_newrelic(*args, &blk)
-                  end
-                end
-              else
-                def pluck(*args, **kwargs, &blk)
-                  ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                    pluck_without_newrelic(*args, **kwargs, &blk)
-                  end
+              def pluck(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  pluck_without_newrelic(*args, &blk)
                 end
               end
+
             end
           end
         end

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

@@ -62,68 +62,34 @@ module NewRelic
         end
 
         module RelationExtensions
-          if RUBY_VERSION < "2.7.0"
-            def update_all(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
-            end
-  
-            def delete_all(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
-            end
-  
-            def destroy_all(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
-            end
-  
-            def calculate(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
-            end
-  
-            def pluck(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
-            end
-            
-          else
-            def update_all(*args, **kwargs, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
+          def update_all(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
             end
-  
-            def delete_all(*args, **kwargs, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
-            end
-  
-            def destroy_all(*args, **kwargs, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
+          end
+
+          def delete_all(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
             end
-  
-            def calculate(*args, **kwargs, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
+          end
+
+          def destroy_all(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
             end
-  
-            def pluck(*args, **kwargs, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                super
-              end
+          end
+
+          def calculate(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
             end
+          end
 
+          def pluck(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
+            end
           end
         end
       end

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

@@ -9,7 +9,6 @@ module NewRelic
     module ActsAsSolrInstrumentation
       module ParserMethodsInstrumentation
 
-        if RUBY_VERSION < "2.7.0"
           def parse_query_with_newrelic(*args)
             self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
               begin
@@ -20,20 +19,6 @@ module NewRelic
               end
             end
           end
-  
-        else
-          def parse_query_with_newrelic(*args, **kwargs)
-            self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
-              begin
-                parse_query_without_newrelic(*args, **kwargs)
-              ensure
-                return unless txn = ::NewRelic::Agent::Tracer.current_transaction
-                txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
-              end
-            end
-          end
-  
-        end
       end
     end
   end

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

@@ -100,48 +100,24 @@ DependencyDetection.defer do
 
         alias_method :purge_without_new_relic, :purge
 
-        if RUBY_VERSION < "2.7.0"
-          def purge *args
-            begin
-              type = server_named? ? :temporary_queue : :queue
-              segment = NewRelic::Agent::Tracer.start_message_broker_segment(
-                action: :purge,
-                library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-                destination_type: type,
-                destination_name: name
-              )
-            rescue => e
-              NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
+        def purge *args
+          begin
+            type = server_named? ? :temporary_queue : :queue
+            segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+              action: :purge,
+              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+              destination_type: type,
+              destination_name: name
+            )
+          rescue => e
+            NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
+            purge_without_new_relic(*args)
+          else
+            NewRelic::Agent::Tracer.capture_segment_error segment do
               purge_without_new_relic(*args)
-            else
-              NewRelic::Agent::Tracer.capture_segment_error segment do
-                purge_without_new_relic(*args)
-              end
-            ensure
-              segment.finish if segment
-            end
-          end
-
-        else     
-          def purge *args, **kwargs
-            begin
-              type = server_named? ? :temporary_queue : :queue
-              segment = NewRelic::Agent::Tracer.start_message_broker_segment(
-                action: :purge,
-                library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-                destination_type: type,
-                destination_name: name
-              )
-            rescue => e
-              NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
-              purge_without_new_relic(*args, **kwargs)
-            else
-              NewRelic::Agent::Tracer.capture_segment_error segment do
-                purge_without_new_relic(*args, **kwargs)
-              end
-            ensure
-              segment.finish if segment
             end
+          ensure
+            segment.finish if segment
           end
         end
 
@@ -150,42 +126,22 @@ DependencyDetection.defer do
       class Consumer
         alias_method :call_without_new_relic, :call
 
-        if RUBY_VERSION < "2.7.0"
-          def call *args
-            delivery_info, message_properties, _ = args
-            queue_name = queue.respond_to?(:name) ? queue.name : queue
-  
-            NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
-              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-              destination_name: NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
-              delivery_info: delivery_info,
-              message_properties: message_properties,
-              exchange_type: NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel),
-              queue_name: queue_name) do
-  
-              call_without_new_relic(*args)
-            end
-          end
-        else
-          def call *args, **kwargs
-            delivery_info, message_properties, _ = args
-            queue_name = queue.respond_to?(:name) ? queue.name : queue
+        def call *args
+          delivery_info, message_properties, _ = args
+          queue_name = queue.respond_to?(:name) ? queue.name : queue
 
-            NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
-              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-              destination_name: NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
-              delivery_info: delivery_info,
-              message_properties: message_properties,
-              exchange_type: NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel),
-              queue_name: queue_name) do
+          NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
+            library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+            destination_name: NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
+            delivery_info: delivery_info,
+            message_properties: message_properties,
+            exchange_type: NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel),
+            queue_name: queue_name) do
 
-              call_without_new_relic(*args, **kwargs)
-            end
+            call_without_new_relic(*args)
           end
         end
 
-
-
       end
     end
   end