newrelic_rpm 6.1.0.352 → 6.6.0.358

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

@@ -1,12 +1,12 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require 'new_relic/agent/instrumentation/evented_subscriber'
+require 'new_relic/agent/instrumentation/notifications_subscriber'
 
 module NewRelic
   module Agent
     module Instrumentation
-      class ActiveStorageSubscriber < EventedSubscriber
+      class ActiveStorageSubscriber < NotificationsSubscriber
         def start name, id, payload
           return unless state.is_execution_traced?
           start_segment name, id, payload
@@ -25,11 +25,11 @@ module NewRelic
           segment = Tracer.start_segment name: metric_name(name, payload)
           segment.params[:key] = payload[:key]
           segment.params[:exist] = payload[:exist] if payload.key? :exist
-          event_stack[id].push segment
+          push_segment id, segment
         end
 
         def finish_segment id
-          segment = event_stack[id].pop
+          segment = pop_segment id
           segment.finish if segment
         end
 

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

@@ -133,9 +133,8 @@ DependencyDetection.defer do
             endpoint = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
             version = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_VERSION]
 
-            # Since 1.2.0, how to obtain the class name is changed.
-            class_name = self.class.respond_to?(:base) ? self.class.base.name : self.class.name
-            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, class_name, 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

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

@@ -0,0 +1,76 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class NotificationsSubscriber
+        def initialize
+          @queue_key = ['NewRelic', self.class.name, object_id].join('-')
+        end
+
+        def self.subscribed?
+          find_all_subscribers.find{|s| s.instance_variable_get(:@delegate).class == self }
+        end
+
+        def self.find_all_subscribers
+          # TODO: need to talk to Rails core about an API for this,
+          # rather than digging through Listener ivars
+          instance_variable_names = [:@subscribers, :@string_subscribers, :@other_subscribers]
+          all_subscribers = []
+
+          notifier = ActiveSupport::Notifications.notifier
+
+          instance_variable_names.each do |name| 
+            if notifier.instance_variable_defined?(name)
+              subscribers = notifier.instance_variable_get(name)
+              if subscribers.is_a? Array
+                # Rails 5 @subscribers, and Rails 6 @other_subscribers is a
+                # plain array of subscriber objects
+                all_subscribers += subscribers
+              elsif subscribers.is_a? Hash
+                # Rails 6 @string_subscribers is a Hash mapping the pattern
+                # string of a subscriber to an array of subscriber objects
+                subscribers.values.each { |array| all_subscribers += array }
+              end
+            end
+          end
+
+          all_subscribers
+        end
+
+        def self.subscribe(pattern)
+          if !subscribed?
+            ActiveSupport::Notifications.subscribe(pattern, new)
+          end
+        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.
+          NewRelic::Agent.logger.error("Error during #{event_type} callback for event '#{name}':")
+          NewRelic::Agent.logger.log_exception(:error, error)
+        end
+
+        def push_segment(id, segment)
+          segment_stack[id].push segment
+        end
+
+        def pop_segment(id)
+          segment = segment_stack[id].pop
+          segment
+        end
+
+        def segment_stack
+          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
+        end
+
+        def state
+          NewRelic::Agent::Tracer.state
+        end
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/{rails5 → rails_notifications}/action_cable.rb

@@ -5,11 +5,11 @@ require 'new_relic/agent/instrumentation/action_cable_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
 DependencyDetection.defer do
-  @name = :rails5_action_cable
+  @name = :action_cable_notifications
 
   depends_on do
     defined?(::Rails::VERSION::MAJOR) &&
-     ::Rails::VERSION::MAJOR.to_i == 5 &&
+     ::Rails::VERSION::MAJOR.to_i >= 5 &&
        defined?(::ActionCable)
   end
 
@@ -19,7 +19,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 5 Action Cable instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing notifications based Action Cable instrumentation'
   end
 
   executes do
@@ -28,9 +28,8 @@ DependencyDetection.defer do
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
     ActiveSupport.on_load(:action_cable) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
-        ::ActionCable::Engine,
-        ::ActionCable::RemoteConnections)
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::Engine) if defined?(::ActionCable::Engine)
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::RemoteConnections) if defined?(::ActionCable::RemoteConnections)
     end
   end
 end

data/lib/new_relic/agent/instrumentation/{rails5 → rails_notifications}/action_controller.rb

@@ -6,10 +6,10 @@ require 'new_relic/agent/prepend_supportability'
 
 
 DependencyDetection.defer do
-  @name = :rails5_controller
+  @name = :action_controller_notifications
 
   depends_on do
-    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i == 5
+    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i >= 4
   end
 
   depends_on do
@@ -17,7 +17,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 5 Controller instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing notifications based Action Controller instrumentation'
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/{rails4 → rails_notifications}/action_view.rb

@@ -5,10 +5,10 @@ require 'new_relic/agent/instrumentation/action_view_subscriber'
 require 'new_relic/agent/prepend_supportability'
 
 DependencyDetection.defer do
-  @name = :rails4_view
+  @name = :action_view_notifications
 
   depends_on do
-    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i == 4
+    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i >= 4
   end
 
   depends_on do
@@ -17,7 +17,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 4 view instrumentation'
+    NewRelic::Agent.logger.info 'Installing notification based Action View instrumentation'
   end
 
   executes do

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -14,7 +14,7 @@ module NewRelic
       RUM_KEY_LENGTH = 13
 
       def initialize(event_listener)
-        event_listener.subscribe(:finished_configuring, &method(:log_configuration))
+        event_listener.subscribe(:initial_configuration_complete, &method(:log_configuration))
       end
 
       def log_configuration

data/lib/new_relic/agent/new_relic_service.rb

@@ -163,10 +163,6 @@ module NewRelic
         invoke_remote(:agent_command_results, [@agent_id, results])
       end
 
-      def get_xray_metadata(xray_ids)
-        invoke_remote(:get_xray_metadata, [@agent_id, *xray_ids])
-      end
-
       def analytic_event_data(data)
         _, items = data
         invoke_remote(:analytic_event_data, [@agent_id, *data],

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

@@ -39,7 +39,6 @@ module NewRelic
 
         def load(data)
           if data.nil? || data.empty?
-            ::NewRelic::Agent.logger.error "Empty JSON response from collector: '#{data.inspect}'"
             return nil
           end
 

data/lib/new_relic/agent/parameter_filtering.rb

@@ -7,16 +7,29 @@ module NewRelic
     module ParameterFiltering
       extend self
 
+      ACTION_DISPATCH_PARAMETER_FILTER = "action_dispatch.parameter_filter".freeze
+
+      RAILS_FILTER_CLASS = if defined?(ActiveSupport::ParameterFilter)
+         ActiveSupport::ParameterFilter
+      elsif defined?(ActionDispatch::Http::ParameterFilter)
+        ActionDispatch::Http::ParameterFilter
+      else
+        nil
+      end
+
       def apply_filters(env, params)
-        params = filter_using_rails(env, params)
+        if filters = env[ACTION_DISPATCH_PARAMETER_FILTER]
+          params = filter_using_rails(params, filters) 
+        end
         params = filter_rack_file_data(env, params)
         params
       end
 
-      def filter_using_rails(env, params)
-        return params unless defined?(ActionDispatch::Http::ParameterFilter) && env.key?("action_dispatch.parameter_filter")
-        filters = env["action_dispatch.parameter_filter"]
-        ActionDispatch::Http::ParameterFilter.new(filters).filter(params)
+      def filter_using_rails(params, filters)
+        return params if RAILS_FILTER_CLASS.nil?
+
+        pre_filtered_params = filter_rails_request_parameters(params)
+        RAILS_FILTER_CLASS.new(filters).filter(pre_filtered_params)
       end
 
       def filter_rack_file_data(env, params)

data/lib/new_relic/agent/priority_sampled_buffer.rb

@@ -22,6 +22,8 @@ module NewRelic
       def append(priority: nil, event: nil, &blk)
         increment_seen
 
+        return if @capacity == 0
+
         if @seen == @capacity
           @items = Heap.new(@items) { |x| priority_for(x) }
         end

data/lib/new_relic/agent/span_event_aggregator.rb

@@ -12,11 +12,8 @@ module NewRelic
     class SpanEventAggregator < EventAggregator
       named :SpanEventAggregator
       capacity_key :'span_events.max_samples_stored'
-
-      enabled_fn -> {
-        NewRelic::Agent.config[:'span_events.enabled'] &&
-        NewRelic::Agent.config[:'distributed_tracing.enabled']
-      }
+      enabled_keys :'span_events.enabled',
+                   :'distributed_tracing.enabled'
 
       def record priority: nil, event:nil, &blk
         unless(event || priority && blk)

data/lib/new_relic/agent/threading/backtrace_service.rb

@@ -36,8 +36,8 @@ module NewRelic
           @worker_loop = NewRelic::Agent::WorkerLoop.new
 
           # Memoize overhead % to avoid getting stale OR looked up every poll
-          @overhead_percent_threshold = NewRelic::Agent.config[:'xray_session.max_profile_overhead']
-          NewRelic::Agent.config.register_callback(:'xray_session.max_profile_overhead') do |new_value|
+          @overhead_percent_threshold = NewRelic::Agent.config[:'thread_profiler.max_profile_overhead']
+          NewRelic::Agent.config.register_callback(:'thread_profiler.max_profile_overhead') do |new_value|
             @overhead_percent_threshold = new_value
           end
 
@@ -213,7 +213,7 @@ module NewRelic
             if @buffer[thread].length < MAX_BUFFER_LENGTH
               @buffer[thread] << [timestamp, backtrace]
             else
-              NewRelic::Agent.increment_metric('Supportability/XraySessions/DroppedBacktraces')
+              NewRelic::Agent.increment_metric('Supportability/ThreadProfiler/DroppedBacktraces')
             end
           end
         end

data/lib/new_relic/agent/threading/thread_profile.rb

@@ -16,7 +16,7 @@ module NewRelic
 
         attr_reader :profile_id, :traces, :sample_period,
           :duration, :poll_count, :backtrace_count, :failure_count,
-          :created_at, :xray_id, :command_arguments, :profile_agent_code
+          :created_at, :command_arguments, :profile_agent_code
         attr_accessor :finished_at
 
         def initialize(command_arguments={})
@@ -25,7 +25,6 @@ module NewRelic
           @duration           = command_arguments.fetch('duration', 120)
           @sample_period      = command_arguments.fetch('sample_period', 0.1)
           @profile_agent_code = command_arguments.fetch('profile_agent_code', false)
-          @xray_id            = command_arguments.fetch('x_ray_id', nil)
           @finished = false
 
           @traces = {
@@ -51,14 +50,6 @@ module NewRelic
           @poll_count += 1
         end
 
-        def sample_count
-          xray? ? @backtrace_count : @poll_count
-        end
-
-        def xray?
-          !!@xray_id
-        end
-
         def empty?
           @backtrace_count == 0
         end
@@ -121,26 +112,21 @@ module NewRelic
         def to_collector_array(encoder)
           encoded_trace_tree = encoder.encode(generate_traces, :skip_normalization => true)
           result = [
-            int(self.profile_id),
-            float(self.created_at),
-            float(self.finished_at),
-            int(self.sample_count),
+            int(profile_id),
+            float(created_at),
+            float(finished_at),
+            int(poll_count),
             encoded_trace_tree,
-            int(self.unique_thread_count),
+            int(unique_thread_count),
             0 # runnable thread count, which we don't track
           ]
-          result << int(@xray_id) if xray?
           result
         end
 
         def to_log_description
-          id = if xray?
-                 "@xray_id: #{xray_id}"
-               else
-                 "@profile_id: #{profile_id}"
-               end
-
-          "#<ThreadProfile:#{object_id} #{id} @command_arguments=#{@command_arguments.inspect}>"
+          "#<ThreadProfile:#{object_id} "\
+            "@profile_id: #{profile_id} "\
+            "@command_arguments=#{@command_arguments.inspect}>"
         end
 
       end

data/lib/new_relic/agent/transaction.rb

@@ -355,8 +355,6 @@ module NewRelic
 
       # For common interface with Trace
       alias_method :transaction_name, :best_name
-
-      attr_accessor :xray_session_id
       # End common interface
 
       def promoted_transaction_name(name)

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

@@ -11,7 +11,7 @@ module NewRelic
         class FinishedTraceError < StandardError; end
 
         attr_reader :start_time, :root_node
-        attr_accessor :transaction_name, :guid, :xray_session_id, :attributes,
+        attr_accessor :transaction_name, :guid, :attributes,
                       :node_count, :finished, :threshold, :profile
 
         ROOT = "ROOT".freeze
@@ -40,11 +40,6 @@ module NewRelic
           self.root_node.duration
         end
 
-        def forced?
-          return true if NewRelic::Coerce.int_or_nil(xray_session_id)
-          false
-        end
-
         def synthetics_resource_id
           intrinsic_attributes = attributes.intrinsic_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER)
           intrinsic_attributes[:synthetics_resource_id]
@@ -148,8 +143,8 @@ module NewRelic
             encoder.encode(trace_tree(attributes_hash)),
             NewRelic::Coerce.string(self.guid),
             nil,
-            forced?,
-            NewRelic::Coerce.int_or_nil(xray_session_id),
+            false, # forced?,
+            nil, # NewRelic::Coerce.int_or_nil(xray_session_id),
             NewRelic::Coerce.string(self.synthetics_resource_id)
           ]
         end

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

@@ -48,7 +48,6 @@ module NewRelic
           trace.guid = transaction.guid
           trace.attributes = transaction.attributes
           trace.threshold = transaction.threshold
-          trace.xray_session_id = transaction.xray_session_id
           trace.finished = true
         end
       end

data/lib/new_relic/agent/transaction_event_recorder.rb

@@ -14,9 +14,9 @@ module NewRelic
       attr_reader :transaction_event_aggregator
       attr_reader :synthetics_event_aggregator
 
-      def initialize
-        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new
-        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new
+      def initialize events
+        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new events
+        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new events
       end
 
       def record payload

data/lib/new_relic/agent/transaction_sampler.rb

@@ -4,7 +4,6 @@
 
 require 'new_relic/agent/transaction/slowest_sample_buffer'
 require 'new_relic/agent/transaction/synthetics_sample_buffer'
-require 'new_relic/agent/transaction/xray_sample_buffer'
 require 'new_relic/agent/transaction/trace_builder'
 
 module NewRelic
@@ -19,13 +18,10 @@ module NewRelic
     #
     # @api public
     class TransactionSampler
-      attr_reader :last_sample, :xray_sample_buffer
+      attr_reader :last_sample
 
       def initialize
-        @xray_sample_buffer = NewRelic::Agent::Transaction::XraySampleBuffer.new
-
         @sample_buffers = []
-        @sample_buffers << @xray_sample_buffer
         @sample_buffers << NewRelic::Agent::Transaction::SlowestSampleBuffer.new
         @sample_buffers << NewRelic::Agent::Transaction::SyntheticsSampleBuffer.new