newrelic_rpm 8.15.0 → 9.0.0

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

@@ -2,11 +2,26 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-# This is a helper file that will allow apps using ActiveSupport without Rails
-# to still leverage all ActiveSupport based instrumentation functionality
-# offered by the agent that would otherwise be gated by the detection of Rails.
+require 'new_relic/agent/instrumentation/active_support_subscriber'
 
-# ActiveSupport notifications custom events
-if !defined?(Rails) && defined?(ActiveSupport::Notifications) && defined?(ActiveSupport::IsolatedExecutionState)
-  require_relative 'rails_notifications/custom_events'
+DependencyDetection.defer do
+  named :active_support
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_active_support]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      !NewRelic::Agent::Instrumentation::ActiveSupportSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActiveSupport instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\.active_support$/,
+      NewRelic::Agent::Instrumentation::ActiveSupportSubscriber.new)
+  end
 end

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

@@ -0,0 +1,41 @@
+# 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 'new_relic/agent/instrumentation/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActiveSupportSubscriber < NotificationsSubscriber
+        def add_segment_params(segment, payload)
+          segment.params[:key] = payload[:key]
+          segment.params[:store] = payload[:store]
+          segment.params[:hit] = payload[:hit] if payload.key?(:hit)
+          segment.params[:super_operation] = payload[:super_operation] if payload.key?(:super_operation)
+          segment
+        end
+
+        def metric_name(name, payload)
+          store = payload[:store]
+          method = method_from_name(name)
+          "Ruby/ActiveSupport#{"/#{store}" if store}/#{method}"
+        end
+
+        PATTERN = /\Acache_([^\.]*)\.active_support\z/
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = NewRelic::UNKNOWN
+          end
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -180,7 +180,7 @@ module NewRelic
             code_info = NewRelic::Agent::MethodTracerHelpers.code_information(self, method)
             argument_list = generate_argument_list(options.merge(code_info))
 
-            class_eval(<<-EOC)
+            class_eval(<<~EOC)
               def #{with_method_name}(*args, &block)
                 perform_action_with_newrelic_trace(#{argument_list.join(',')}) do
                   #{without_method_name}(*args, &block)

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

@@ -0,0 +1,12 @@
+# 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
+
+# This is a helper file that will allow apps using ActiveSupport without Rails
+# to still leverage all ActiveSupport based instrumentation functionality
+# offered by the agent that would otherwise be gated by the detection of Rails.
+
+# ActiveSupport notifications custom events
+if !defined?(Rails) && defined?(ActiveSupport::Notifications) && defined?(ActiveSupport::IsolatedExecutionState)
+  require_relative 'rails_notifications/custom_events'
+end

data/lib/new_relic/agent/instrumentation/fiber/chain.rb

@@ -0,0 +1,20 @@
+# 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::Agent::Instrumentation
+  module MonitoredFiber
+    def self.instrument!
+      ::Fiber.class_eval do
+        include NewRelic::Agent::Instrumentation::MonitoredFiber
+
+        alias_method(:initialize_without_new_relic, :initialize)
+
+        def initialize(*args, &block)
+          traced_block = add_thread_tracing(*args, &block)
+          initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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::Agent::Instrumentation
+  module MonitoredFiber
+    attr_reader :nr_parent_key
+
+    def initialize_with_newrelic_tracing
+      @nr_parent_key = NewRelic::Agent::Tracer.current_segment_key
+      yield
+    end
+
+    def add_thread_tracing(*args, &block)
+      return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
+
+      NewRelic::Agent::Tracer.thread_block_with_current_transaction(
+        *args,
+        segment_name: 'Ruby/Fiber',
+        &block
+      )
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# 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 MonitoredFiber
+    module Prepend
+      include NewRelic::Agent::Instrumentation::MonitoredFiber
+
+      def initialize(*args, &block)
+        traced_block = add_thread_tracing(*args, &block)
+        initialize_with_newrelic_tracing { super(*args, &traced_block) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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 'fiber/instrumentation'
+require_relative 'fiber/chain'
+require_relative 'fiber/prepend'
+
+DependencyDetection.defer do
+  named :fiber
+
+  depends_on do
+    defined?(Fiber)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing Fiber instrumentation')
+
+    if use_prepend?
+      prepend_instrument Fiber, NewRelic::Agent::Instrumentation::MonitoredFiber::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::MonitoredFiber
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ 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
+  @name = :grape_instrumentation
   configure_with :grape
 
   depends_on do

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

@@ -46,7 +46,7 @@ DependencyDetection.defer do
 end
 
 DependencyDetection.defer do
-  named :dalli
+  @name = :dalli
   configure_with :memcache
 
   depends_on { defined? Dalli::Client }
@@ -67,7 +67,7 @@ end
 # dalli/cas/client. Use a separate dependency block so it can potentially
 # re-evaluate after they've done that require.
 DependencyDetection.defer do
-  named :dalli_cas_client
+  @name = :dalli_cas_client
   configure_with :memcache
 
   depends_on { defined? Dalli::Client }

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

@@ -27,7 +27,7 @@ DependencyDetection.defer do
   end
 
   conflicts_with_prepend do
-    defined?(Rack::MiniProfiler)
+    defined?(Rack::MiniProfiler) && !defined?(Rack::MINI_PROFILER_PREPEND_NET_HTTP_PATCH)
   end
 
   conflicts_with_prepend do

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

@@ -47,6 +47,47 @@ module NewRelic
           end
         end
 
+        def start(name, id, payload)
+          return unless state.is_execution_traced?
+
+          start_segment(name, id, payload)
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload)
+          return unless state.is_execution_traced?
+
+          finish_segment(id, payload)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def start_segment(name, id, payload)
+          segment = Tracer.start_segment(name: metric_name(name, payload))
+          add_segment_params(segment, payload)
+          push_segment(id, segment)
+        end
+
+        def finish_segment(id, payload)
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
+        end
+
+        # for subclasses
+        def add_segment_params(segment, payload)
+          # no op
+        end
+
+        # for subclasses
+        def metric_name(name, payload)
+          "Ruby/#{name}"
+        end
+
         def log_notification_error(error, name, event_type)
           # These are important enough failures that we want the backtraces
           # logged at error level, hence the explicit log_exception call.

data/lib/new_relic/agent/instrumentation/rails_notifications/action_cable.rb

@@ -9,9 +9,9 @@ DependencyDetection.defer do
   @name = :action_cable_notifications
 
   depends_on do
-    defined?(Rails::VERSION::MAJOR) &&
-      Rails::VERSION::MAJOR.to_i >= 5 &&
-      defined?(ActionCable)
+    defined?(ActionCable::VERSION::MAJOR) &&
+      ActionCable::VERSION::MAJOR.to_i >= 5 &&
+      defined?(ActiveSupport)
   end
 
   depends_on do
@@ -25,7 +25,7 @@ DependencyDetection.defer do
 
   executes do
     # enumerate the specific events we want so that we do not get unexpected additions in the future
-    ActiveSupport::Notifications.subscribe(/(perform_action|transmit)\.action_cable/,
+    ActiveSupport::Notifications.subscribe(/\A(?:perform_action|transmit|broadcast)\.action_cable\z/,
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
     ActiveSupport.on_load(:action_cable) do

data/lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb

@@ -3,6 +3,7 @@
 # frozen_string_literal: true
 
 require 'new_relic/agent/instrumentation/action_controller_subscriber'
+require 'new_relic/agent/instrumentation/action_controller_other_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
 DependencyDetection.defer do
@@ -13,7 +14,8 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    defined?(ActionController) && (defined?(ActionController::Base) || defined?(ActionController::API))
+    !NewRelic::Agent.config[:disable_action_controller] &&
+      defined?(ActionController) && (defined?(ActionController::Base) || defined?(ActionController::API))
   end
 
   executes do
@@ -29,5 +31,15 @@ DependencyDetection.defer do
 
     NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
       .subscribe(/^process_action.action_controller$/)
+
+    subs = %w[send_file
+      send_data
+      redirect_to
+      halted_callback
+      unpermitted_parameters]
+
+    # have to double escape period because its going from string -> regex
+    NewRelic::Agent::Instrumentation::ActionControllerOtherSubscriber \
+      .subscribe(Regexp.new("^(#{subs.join('|')})\\.action_controller$"))
   end
 end

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

@@ -73,10 +73,6 @@ module NewRelic
           task.instance_eval do
             def invoke_prerequisites_concurrently(*_)
               NewRelic::Agent::MethodTracer.trace_execution_scoped("Rake/execute/multitask") do
-                prereqs = self.prerequisite_tasks.map(&:name).join(", ")
-                if txn = ::NewRelic::Agent::Tracer.current_transaction
-                  txn.current_segment.params[:statement] = NewRelic::Agent::Database.truncate_query("Couldn't trace concurrent prereq tasks: #{prereqs}")
-                end
                 super
               end
             end
@@ -86,12 +82,9 @@ module NewRelic
         def before_invoke_transaction(task)
           ensure_at_exit
 
-          # We can't represent overlapping operations yet, so if multitask just
-          # make one node and annotate with prereq task names
+          instrument_execute_on_prereqs(task)
           if task.application.options.always_multitask
             instrument_invoke_prerequisites_concurrently(task)
-          else
-            instrument_execute_on_prereqs(task)
           end
         rescue => e
           NewRelic::Agent.logger.error("Error during Rake task invoke", e)

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

@@ -8,7 +8,7 @@ require_relative 'rake/prepend'
 
 DependencyDetection.defer do
   # Why not :rake? newrelic-rake used that name, so avoid conflicting
-  named :rake_instrumentation
+  @name = :rake_instrumentation
   configure_with :rake
 
   depends_on { defined?(Rake) && defined?(Rake::VERSION) }

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

@@ -13,7 +13,7 @@ require_relative 'redis/middleware'
 
 DependencyDetection.defer do
   # Why not :redis? newrelic-redis used that name, so avoid conflicting
-  named :redis_instrumentation
+  @name = :redis_instrumentation
   configure_with :redis
 
   depends_on do

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

@@ -10,7 +10,7 @@ DependencyDetection.defer do
   @name = :resque
 
   depends_on do
-    defined?(Resque::Job) && !NewRelic::Agent.config[:disable_resque]
+    defined?(Resque::Job)
   end
 
   # Airbrake uses method chaining on Resque::Job on versions < 11.0.3

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

@@ -11,8 +11,7 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_sequel_instrumentation] &&
-      !NewRelic::Agent.config[:disable_database_instrumentation]
+    !NewRelic::Agent.config[:disable_sequel_instrumentation]
   end
 
   def supported_sequel_version?
@@ -27,7 +26,7 @@ DependencyDetection.defer do
       NewRelic::Agent.logger.info('Installing Sequel instrumentation')
 
       if Sequel::Database.respond_to?(:extension)
-        Sequel::Database.extension(:newrelic_instrumentation)
+        Sequel::Database.extension(:new_relic_instrumentation)
       else
         NewRelic::Agent.logger.info("Detected Sequel version %s." % [Sequel::VERSION])
         NewRelic::Agent.logger.info("Please see additional documentation: " +
@@ -35,10 +34,10 @@ DependencyDetection.defer do
       end
 
       Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|
-        db.extension(:newrelic_instrumentation)
+        db.extension(:new_relic_instrumentation)
       end
 
-      Sequel::Model.plugin(:newrelic_instrumentation) if defined?(Sequel::Model)
+      Sequel::Model.plugin(:new_relic_instrumentation) if defined?(Sequel::Model)
     else
 
       NewRelic::Agent.logger.info("Sequel instrumentation requires at least version 3.37.0.")

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

@@ -6,15 +6,15 @@ module NewRelic
   module Agent
     module Instrumentation
       module MonitoredThread
-        attr_reader :nr_parent_thread_id
+        attr_reader :nr_parent_key
 
         def initialize_with_newrelic_tracing
-          @nr_parent_thread_id = ::Thread.current.object_id
+          @nr_parent_key = NewRelic::Agent::Tracer.current_segment_key
           yield
         end
 
         def add_thread_tracing(*args, &block)
-          return block if skip_tracing?
+          return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
           NewRelic::Agent::Tracer.thread_block_with_current_transaction(
             *args,
@@ -22,10 +22,6 @@ module NewRelic
             &block
           )
         end
-
-        def skip_tracing?
-          !NewRelic::Agent.config[:'instrumentation.thread.tracing']
-        end
       end
     end
   end

data/lib/new_relic/agent/monitors/cross_app_monitor.rb

@@ -12,7 +12,6 @@ module NewRelic
   module Agent
     module DistributedTracing
       class CrossAppMonitor < InboundRequestMonitor
-        NEWRELIC_ID_HEADER = 'X-NewRelic-ID'.freeze
         NEWRELIC_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
         NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
 

data/lib/new_relic/agent/new_relic_service/security_policy_settings.rb

@@ -14,7 +14,6 @@ module NewRelic
           custom_parameters
           custom_instrumentation_editor
           message_parameters
-          job_arguments
         ].map(&:freeze)
 
         def self.preliminary_settings(security_policies)

data/lib/new_relic/agent/new_relic_service.rb

@@ -595,7 +595,7 @@ module NewRelic
         return if post_string.size < Agent.config[:max_payload_size_in_bytes]
 
         ::NewRelic::Agent.logger.debug("Tried to send too much data: #{post_string.size} bytes")
-        NewRelic::Agent.increment_metric("Supportability/Agent/Collector/#{endpoint}/MaxPayloadSizeLimit")
+        NewRelic::Agent.increment_metric("Supportability/Ruby/Collector/#{endpoint}/MaxPayloadSizeLimit")
         raise UnrecoverableServerException.new('413 Request Entity Too Large')
       end
 

data/lib/new_relic/agent/rules_engine/segment_terms_rule.rb

@@ -11,7 +11,6 @@ module NewRelic
         SEGMENT_PLACEHOLDER = '*'.freeze
         ADJACENT_PLACEHOLDERS_REGEX = %r{((?:^|/)\*)(?:/\*)*}.freeze
         ADJACENT_PLACEHOLDERS_REPLACEMENT = '\1'.freeze
-        VALID_PREFIX_SEGMENT_COUNT = 2
 
         attr_reader :prefix, :terms
 

data/lib/new_relic/agent/samplers/delayed_job_sampler.rb

@@ -25,7 +25,7 @@ module NewRelic
         end
 
         def initialize
-          raise Unsupported, "DJ queue sampler disabled" if Agent.config[:disable_dj]
+          raise Unsupported, "DJ queue sampler disabled" if Agent.config[:'instrumentation.delayed_job'] == 'disabled'
           raise Unsupported, "DJ queue sampling unsupported with backend '#{::Delayed::Worker.backend}'" unless self.class.supported_backend?
           raise Unsupported, "No DJ worker present. Skipping DJ queue sampler" unless NewRelic::DelayedJobInjection.worker_name
         end

data/lib/new_relic/agent/tracer.rb

@@ -410,8 +410,17 @@ module NewRelic
 
         alias_method :tl_clear, :clear_state
 
+        def current_segment_key
+          ::Fiber.current.object_id
+        end
+
+        def thread_tracing_enabled?
+          NewRelic::Agent.config[:'instrumentation.thread.tracing']
+        end
+
         def thread_block_with_current_transaction(*args, segment_name:, parent: nil, &block)
-          current_txn = ::Thread.current[:newrelic_tracer_state].current_transaction if ::Thread.current[:newrelic_tracer_state] && ::Thread.current[:newrelic_tracer_state].is_execution_traced?
+          parent ||= current_segment
+          current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
           proc do
             begin
               if current_txn

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -20,14 +20,14 @@ module NewRelic
         # after its parent. We will use the optimized exclusive duration
         # calculation in all other cases.
         #
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_thread_id
+        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key
         attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
         def initialize(name = nil, start_time = nil)
           @name = name
-          @starting_thread_id = ::Thread.current.object_id
+          @starting_segment_key = NewRelic::Agent::Tracer.current_segment_key
           @transaction_name = nil
           @transaction = nil
           @guid = NewRelic::Agent::GuidGenerator.generate_guid

data/lib/new_relic/agent/transaction/tracing.rb

@@ -35,8 +35,8 @@ module NewRelic
 
         def segment_complete(segment)
           # if parent was in another thread, remove the current_segment entry for this thread
-          if segment.parent && segment.parent.starting_thread_id != ::Thread.current.object_id
-            remove_current_segment_by_thread_id(::Thread.current.object_id)
+          if segment.parent && segment.parent.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
+            remove_current_segment_by_thread_id(NewRelic::Agent::Tracer.current_segment_key)
           else
             set_current_segment(segment.parent)
           end

data/lib/new_relic/agent/transaction.rb

@@ -53,9 +53,6 @@ module NewRelic
 
       JRUBY_CPU_TIME_ERROR = "Error calculating JRuby CPU Time"
 
-      # reference to the transaction state managing this transaction
-      attr_accessor :state
-
       # A Time instance for the start time, never nil
       attr_accessor :start_time
 
@@ -121,7 +118,6 @@ module NewRelic
       def self.start_new_transaction(state, category, options)
         txn = Transaction.new(category, options)
         state.reset(txn)
-        txn.state = state
         txn.start(options)
         txn
       end
@@ -248,6 +244,7 @@ module NewRelic
         @priority = nil
 
         @starting_thread_id = Thread.current.object_id
+        @starting_segment_key = current_segment_key
 
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
 
@@ -260,20 +257,26 @@ module NewRelic
         end
       end
 
-      def parent_thread_id
-        ::Thread.current.nr_parent_thread_id if ::Thread.current.respond_to?(:nr_parent_thread_id)
+      def state
+        NewRelic::Agent::Tracer.state
       end
 
-      def current_segment
-        current_thread_id = ::Thread.current.object_id
-        return current_segment_by_thread[current_thread_id] if current_segment_by_thread[current_thread_id]
-        return current_segment_by_thread[parent_thread_id] if current_segment_by_thread[parent_thread_id]
+      def current_segment_key
+        Tracer.current_segment_key
+      end
 
-        current_segment_by_thread[@starting_thread_id]
+      def parent_segment_key
+        (::Fiber.current.nr_parent_key if ::Fiber.current.respond_to?(:nr_parent_key)) || (::Thread.current.nr_parent_key if ::Thread.current.respond_to?(:nr_parent_key))
+      end
+
+      def current_segment
+        current_segment_by_thread[current_segment_key] ||
+          current_segment_by_thread[parent_segment_key] ||
+          current_segment_by_thread[@starting_segment_key]
       end
 
       def set_current_segment(new_segment)
-        @current_segment_lock.synchronize { current_segment_by_thread[::Thread.current.object_id] = new_segment }
+        @current_segment_lock.synchronize { current_segment_by_thread[current_segment_key] = new_segment }
       end
 
       def remove_current_segment_by_thread_id(id)
@@ -359,10 +362,8 @@ module NewRelic
       def set_overriding_transaction_name(name, category)
         return log_frozen_name(name) if name_frozen?
 
-        if influences_transaction_name?(category)
-          self.overridden_name = name
-          @category = category if category
-        end
+        self.overridden_name = name
+        @category = category if category
       end
 
       def log_frozen_name(name)