newrelic_rpm 6.2.0.354 → 6.7.0.359

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/logging.rb

@@ -0,0 +1,125 @@
+# 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 'json'
+require 'new_relic/agent/hostname'
+
+module NewRelic
+  module Agent
+    module Logging
+
+      # This class can be used as the formatter for an existing logger.  It
+      # decorates log messages with trace and entity metadata, and formats each
+      # log messages as a JSON object.
+      #
+      # It can be added to a Rails application like this:
+      #
+      #   require 'newrelic_rpm'
+      #
+      #   Rails.application.configure do
+      #     config.log_formatter = ::NewRelic::Agent::Logging::DecoratingFormatter.new
+      #   end
+      #
+      # @api public
+      class DecoratingFormatter < ::Logger::Formatter
+        TIMESTAMP_KEY = 'timestamp'.freeze
+        MESSAGE_KEY = 'message'.freeze
+        LOG_LEVEL_KEY = 'log.level'.freeze
+        LOG_NAME_KEY = 'logger.name'.freeze
+        NEWLINE = "\n".freeze
+
+        QUOTE = '"'.freeze
+        COLON = ':'.freeze
+        COMMA = ','.freeze
+        CLOSING_BRACE = '}'.freeze
+
+        def initialize
+          Agent.config.register_callback :app_name do
+            @app_name = nil
+          end
+        end
+
+        def call severity, time, progname, msg
+          message = '{'
+          if app_name
+            add_key_value message, ENTITY_NAME_KEY, app_name
+            message << COMMA
+          end
+          add_key_value message, ENTITY_TYPE_KEY, ENTITY_TYPE
+          message << COMMA
+          add_key_value message, HOSTNAME_KEY, Hostname.get
+
+          if entity_guid = Agent.config[:entity_guid]
+            message << COMMA
+            add_key_value message, ENTITY_GUID_KEY, entity_guid
+          end
+
+          if trace_id = Tracer.trace_id
+            message << COMMA
+            add_key_value message, TRACE_ID_KEY, trace_id
+          end
+          if span_id = Tracer.span_id
+            message << COMMA
+            add_key_value message, SPAN_ID_KEY, span_id
+          end
+
+          message << COMMA
+          message << QUOTE << MESSAGE_KEY << QUOTE << COLON << escape(msg)
+          message << COMMA
+          add_key_value message, LOG_LEVEL_KEY, severity
+          if progname
+            message << COMMA
+            add_key_value message, LOG_NAME_KEY, progname
+          end
+
+          message << COMMA
+          message << QUOTE << TIMESTAMP_KEY << QUOTE << COLON << time.to_f.to_s
+          message << CLOSING_BRACE << NEWLINE
+        end
+
+        def app_name
+          @app_name ||= Agent.config[:app_name][0]
+        end
+
+        def add_key_value message, key, value
+          message << QUOTE << key << QUOTE << COLON << QUOTE << value << QUOTE
+        end
+
+        def escape message
+          if String === message
+            message.to_json
+          else
+            message.inspect.to_json
+          end
+        end
+      end
+
+
+      # This logger decorates logs with trace and entity metadata, and emits log
+      # messages formatted as JSON objects.  It extends the Logger class from
+      # the Ruby standard library, and accepts the same constructor parameters.
+      #
+      # It aliases the `:info` message to overwrite the `:write` method, so it
+      # can be used in Rack applications that expect the logger to be a file-like
+      # object.
+      #
+      # It can be added to an application like this:
+      #
+      #   require 'newrelic_rpm'
+      #
+      #   config.logger = NewRelic::Agent::Logging::DecoratingLogger.new "log/application.log"
+      #
+      # @api public
+      class DecoratingLogger < (defined?(::ActiveSupport) && defined?(::ActiveSupport::Logger) ? ::ActiveSupport::Logger : ::Logger)
+
+        alias :write :info
+
+        def initialize *args
+          super
+          self.formatter = DecoratingFormatter.new
+        end
+      end
+    end
+  end
+end

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/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