newrelic_rpm 4.8.0.341 → 6.13.1

data/lib/new_relic/agent/agent_logger.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'thread'
 require 'logger'
@@ -173,6 +173,10 @@ module NewRelic
         StartupLogger.instance.dump(self)
       end
 
+      def self.format_fatal_error message
+        "** [NewRelic] FATAL : #{message}\n"
+      end
+
     end
 
     # In an effort to not lose messages during startup, we trap them in memory

data/lib/new_relic/agent/attribute_filter.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # This class applies filtering rules as specified in the Agent Attributes
 # cross-agent spec.
@@ -64,42 +64,55 @@ module NewRelic
     class AttributeFilter
       DST_NONE = 0x0
 
-      DST_TRANSACTION_EVENTS = 1 << 0
-      DST_TRANSACTION_TRACER = 1 << 1
-      DST_ERROR_COLLECTOR    = 1 << 2
-      DST_BROWSER_MONITORING = 1 << 3
+      DST_TRANSACTION_EVENTS   = 1 << 0
+      DST_TRANSACTION_TRACER   = 1 << 1
+      DST_ERROR_COLLECTOR      = 1 << 2
+      DST_BROWSER_MONITORING   = 1 << 3
+      DST_SPAN_EVENTS          = 1 << 4
+      DST_TRANSACTION_SEGMENTS = 1 << 5
 
-      DST_ALL = 0xF
+      DST_ALL                  = 0x3f
 
       attr_reader :rules
 
       def initialize(config)
         @enabled_destinations = DST_NONE
 
-        @enabled_destinations |= DST_TRANSACTION_TRACER if config[:'transaction_tracer.attributes.enabled']
-        @enabled_destinations |= DST_TRANSACTION_EVENTS if config[:'transaction_events.attributes.enabled']
-        @enabled_destinations |= DST_ERROR_COLLECTOR    if config[:'error_collector.attributes.enabled']
-        @enabled_destinations |= DST_BROWSER_MONITORING if config[:'browser_monitoring.attributes.enabled']
+        @enabled_destinations |= DST_TRANSACTION_TRACER   if config[:'transaction_tracer.attributes.enabled']
+        @enabled_destinations |= DST_TRANSACTION_EVENTS   if config[:'transaction_events.attributes.enabled']
+        @enabled_destinations |= DST_ERROR_COLLECTOR      if config[:'error_collector.attributes.enabled']
+        @enabled_destinations |= DST_BROWSER_MONITORING   if config[:'browser_monitoring.attributes.enabled']
+        @enabled_destinations |= DST_SPAN_EVENTS          if config[:'span_events.attributes.enabled']
+        @enabled_destinations |= DST_TRANSACTION_SEGMENTS if config[:'transaction_segments.attributes.enabled']
 
         @enabled_destinations = DST_NONE unless config[:'attributes.enabled']
 
         @rules = []
 
         build_rule(config[:'attributes.exclude'], DST_ALL, false)
-        build_rule(config[:'transaction_tracer.attributes.exclude'], DST_TRANSACTION_TRACER, false)
-        build_rule(config[:'transaction_events.attributes.exclude'], DST_TRANSACTION_EVENTS, false)
-        build_rule(config[:'error_collector.attributes.exclude'],    DST_ERROR_COLLECTOR,    false)
-        build_rule(config[:'browser_monitoring.attributes.exclude'], DST_BROWSER_MONITORING, false)
+        build_rule(config[:'transaction_tracer.attributes.exclude'],   DST_TRANSACTION_TRACER,   false)
+        build_rule(config[:'transaction_events.attributes.exclude'],   DST_TRANSACTION_EVENTS,   false)
+        build_rule(config[:'error_collector.attributes.exclude'],      DST_ERROR_COLLECTOR,      false)
+        build_rule(config[:'browser_monitoring.attributes.exclude'],   DST_BROWSER_MONITORING,   false)
+        build_rule(config[:'span_events.attributes.exclude'],          DST_SPAN_EVENTS,          false)
+        build_rule(config[:'transaction_segments.attributes.exclude'], DST_TRANSACTION_SEGMENTS, false)
 
         build_rule(['request.parameters.*'], include_destinations_for_capture_params(config[:capture_params]), true)
         build_rule(['job.resque.args.*'],    include_destinations_for_capture_params(config[:'resque.capture_params']), true)
         build_rule(['job.sidekiq.args.*'],   include_destinations_for_capture_params(config[:'sidekiq.capture_params']), true)
 
+        build_rule(['host', 'port_path_or_id'], DST_TRANSACTION_SEGMENTS, config[:'datastore_tracer.instance_reporting.enabled'])
+        build_rule(['database_name'],           DST_TRANSACTION_SEGMENTS, config[:'datastore_tracer.database_name_reporting.enabled'])
+
         build_rule(config[:'attributes.include'], DST_ALL, true)
-        build_rule(config[:'transaction_tracer.attributes.include'], DST_TRANSACTION_TRACER, true)
-        build_rule(config[:'transaction_events.attributes.include'], DST_TRANSACTION_EVENTS, true)
-        build_rule(config[:'error_collector.attributes.include'],    DST_ERROR_COLLECTOR,    true)
-        build_rule(config[:'browser_monitoring.attributes.include'], DST_BROWSER_MONITORING, true)
+        build_rule(config[:'transaction_tracer.attributes.include'],   DST_TRANSACTION_TRACER,   true)
+        build_rule(config[:'transaction_events.attributes.include'],   DST_TRANSACTION_EVENTS,   true)
+        build_rule(config[:'error_collector.attributes.include'],      DST_ERROR_COLLECTOR,      true)
+        build_rule(config[:'browser_monitoring.attributes.include'],   DST_BROWSER_MONITORING,   true)
+        build_rule(config[:'span_events.attributes.include'],          DST_SPAN_EVENTS,          true)
+        build_rule(config[:'transaction_segments.attributes.include'], DST_TRANSACTION_SEGMENTS, true)
+
+        build_uri_rule(config[:'attributes.exclude'])
 
         @rules.sort!
 
@@ -107,7 +120,33 @@ module NewRelic
         # filter is re-generated on any significant config change.
         @high_security = config[:high_security]
 
-        cache_prefix_blacklist
+        setup_key_cache
+        cache_prefix_denylist
+      end
+
+      # Note the key_cache is a global cache, accessible by multiple threads,
+      # but is intentionally left unsynchronized for liveness. Writes will always
+      # involve writing the same boolean value for each key, so there is no
+      # worry of one value clobbering another. For reads, if a value hasn't been
+      # written to the cache yet, the worst that will happen is that it will run
+      # through the filter rules again. Both reads and writes will become
+      # eventually consistent.
+
+      def setup_key_cache
+        destinations = [
+          DST_TRANSACTION_EVENTS,
+          DST_TRANSACTION_TRACER,
+          DST_ERROR_COLLECTOR,
+          DST_BROWSER_MONITORING,
+          DST_SPAN_EVENTS,
+          DST_TRANSACTION_SEGMENTS,
+          DST_ALL
+        ]
+
+        @key_cache = destinations.inject({}) do |memo, destination|
+          memo[destination] = {}
+          memo
+        end
       end
 
       def include_destinations_for_capture_params(capturing)
@@ -125,6 +164,14 @@ module NewRelic
         end
       end
 
+      def build_uri_rule(excluded_attributes)
+        uri_aliases = %w(uri url request_uri request.uri http.url)
+
+        if (excluded_attributes & uri_aliases).size > 0
+          build_rule(uri_aliases - excluded_attributes, DST_ALL, false)
+        end
+      end
+
       def apply(attribute_name, default_destinations)
         return DST_NONE if @enabled_destinations == DST_NONE
 
@@ -148,6 +195,19 @@ module NewRelic
         allowed_destinations & requested_destination == requested_destination
       end
 
+      def allows_key?(key, destination)
+        return false unless destination & @enabled_destinations == destination
+
+        value = @key_cache[destination][key]
+
+        if value.nil?
+          allowed_destinations = apply(key, destination)
+          @key_cache[destination][key] = allows?(allowed_destinations, destination)
+        else
+          value
+        end
+      end
+
       def high_security?
         @high_security
       end
@@ -162,16 +222,16 @@ module NewRelic
       # arguments for Sidekiq and Resque in the common case, since none of
       # these attributes are captured by default.
       #
-      def cache_prefix_blacklist
-        @prefix_blacklist = {}
-        @prefix_blacklist[:'request.parameters'] = true unless might_allow_prefix_uncached?(:'request.parameters')
-        @prefix_blacklist[:'job.sidekiq.args']   = true unless might_allow_prefix_uncached?(:'job.sidekiq.args')
-        @prefix_blacklist[:'job.resque.args']    = true unless might_allow_prefix_uncached?(:'job.resque.args')
+      def cache_prefix_denylist
+        @prefix_denylist = {}
+        @prefix_denylist[:'request.parameters'] = true unless might_allow_prefix_uncached?(:'request.parameters')
+        @prefix_denylist[:'job.sidekiq.args']   = true unless might_allow_prefix_uncached?(:'job.sidekiq.args')
+        @prefix_denylist[:'job.resque.args']    = true unless might_allow_prefix_uncached?(:'job.resque.args')
       end
 
       # Note that the given prefix *must* be a Symbol
       def might_allow_prefix?(prefix)
-        !@prefix_blacklist.include?(prefix)
+        !@prefix_denylist.include?(prefix)
       end
 
       def might_allow_prefix_uncached?(prefix)

data/lib/new_relic/agent/attribute_processing.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent

data/lib/new_relic/agent/attributes.rb

@@ -0,0 +1,152 @@
+# 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.
+
+require 'new_relic/agent/attribute_processing'
+
+module NewRelic
+  module Agent
+    class Attributes
+      KEY_LIMIT   = 255
+      VALUE_LIMIT = 255
+      COUNT_LIMIT = 64
+
+      attr_reader :custom_attributes
+
+      def initialize(filter)
+        @filter = filter
+
+        @custom_attributes = {}
+        @agent_attributes = {}
+        @intrinsic_attributes = {}
+
+        @custom_destinations = {}
+        @agent_destinations = {}
+        @already_warned_count_limit = nil
+      end
+
+      def add_agent_attribute(key, value, default_destinations)
+        destinations = @filter.apply(key, default_destinations)
+        return if destinations == AttributeFilter::DST_NONE
+
+        @agent_destinations[key] = destinations
+        add(@agent_attributes, key, value)
+      end
+
+      def add_agent_attribute_with_key_check(key, value, default_destinations)
+        if exceeds_bytesize_limit? key, KEY_LIMIT
+          NewRelic::Agent.logger.debug("Agent attribute #{key} was dropped for exceeding key length limit #{KEY_LIMIT}")
+          return
+        end
+
+        add_agent_attribute(key, value, default_destinations)
+      end
+
+      def add_intrinsic_attribute(key, value)
+        add(@intrinsic_attributes, key, value)
+      end
+
+      def merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+        return if @filter.high_security?
+        return if !@filter.might_allow_prefix?(prefix)
+
+        AttributeProcessing.flatten_and_coerce(attributes, prefix) do |k, v|
+          add_agent_attribute_with_key_check(k, v, AttributeFilter::DST_NONE)
+        end
+      end
+
+      def merge_custom_attributes(other)
+        return unless Agent.config[:'custom_attributes.enabled']
+        return if other.empty?
+        AttributeProcessing.flatten_and_coerce(other) do |k, v|
+          add_custom_attribute(k, v)
+        end
+      end
+
+      def custom_attributes_for(destination)
+        for_destination(@custom_attributes, @custom_destinations, destination)
+      end
+
+      def agent_attributes_for(destination)
+        for_destination(@agent_attributes, @agent_destinations, destination)
+      end
+
+      def intrinsic_attributes_for(destination)
+        if destination == NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER ||
+           destination == NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
+          @intrinsic_attributes
+        else
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      private
+
+      def add_custom_attribute(key, value)
+        if @custom_attributes.size >= COUNT_LIMIT
+          unless @already_warned_count_limit
+            NewRelic::Agent.logger.warn("Custom attributes count exceeded limit of #{COUNT_LIMIT}. Any additional custom attributes during this transaction will be dropped.")
+            @already_warned_count_limit = true
+          end
+          return
+        end
+
+        if @filter.high_security?
+          NewRelic::Agent.logger.debug("Unable to add custom attribute #{key} while in high security mode.")
+          return
+        end
+
+        if exceeds_bytesize_limit?(key, KEY_LIMIT)
+          NewRelic::Agent.logger.warn("Custom attribute key '#{key}' was longer than limit of #{KEY_LIMIT} bytes. This attribute will be dropped.")
+          return
+        end
+
+        destinations = @filter.apply(key, AttributeFilter::DST_ALL)
+        return if destinations == AttributeFilter::DST_NONE
+
+        @custom_destinations[key] = destinations
+        add(@custom_attributes, key, value)
+      end
+
+      def add(attributes, key, value)
+        return if value.nil?
+
+        if exceeds_bytesize_limit?(value, VALUE_LIMIT)
+          value = slice(value)
+        end
+
+        attributes[key] = value
+      end
+
+      def for_destination(attributes, calculated_destinations, destination)
+        # Avoid allocating anything if there are no attrs at all
+        return NewRelic::EMPTY_HASH if attributes.empty?
+
+        attributes.inject({}) do |memo, (key, value)|
+          if @filter.allows?(calculated_destinations[key], destination)
+            memo[key] = value
+          end
+          memo
+        end
+      end
+
+      def exceeds_bytesize_limit?(value, limit)
+        if value.respond_to?(:bytesize)
+          value.bytesize > limit
+        elsif value.is_a?(Symbol)
+          value.to_s.bytesize > limit
+        else
+          false
+        end
+      end
+
+      # Take one byte past our limit. Why? This lets us unconditionally chop!
+      # the end. It'll either remove the one-character-too-many we have, or
+      # peel off the partial, mangled character left by the byteslice.
+      def slice(incoming)
+        result = incoming.to_s.byteslice(0, VALUE_LIMIT + 1)
+        result.chop!
+      end
+    end
+  end
+end

data/lib/new_relic/agent/audit_logger.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'logger'
 require 'fileutils'

data/lib/new_relic/agent/autostart.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent
@@ -20,23 +20,28 @@ module NewRelic
 
 
       # The constants, executables (i.e. $0) and rake tasks used can be
-      # configured with the config keys 'autostart.blacklisted_constants',
-      # 'autostart.blacklisted_executables' and
-      # 'autostart.blacklisted_rake_tasks'
+      # configured with the config keys 'autostart.denylisted_constants',
+      # 'autostart.denylisted_executables' and
+      # 'autostart.denylisted_rake_tasks'
       def agent_should_start?
-          !blacklisted_constants? &&
-          !blacklisted_executables? &&
-          !in_blacklisted_rake_task?
+          !denylisted_constants? &&
+          !denylisted_executables? &&
+          !in_denylisted_rake_task?
       end
 
-      def blacklisted_constants?
-        blacklisted?(NewRelic::Agent.config[:'autostart.blacklisted_constants']) do |name|
+      COMMA = ",".freeze
+
+      def denylisted_constants?
+        # For backwards compatibility until :'autostart_blacklisted_constants' config option is removed
+        constants = NewRelic::Agent.config[:'autostart.denylisted_constants'] << COMMA << NewRelic::Agent.config[:'autostart.blacklisted_constants']
+
+        denylisted?(constants) do |name|
           constant_is_defined?(name)
         end
       end
 
-      def blacklisted_executables?
-        blacklisted?(NewRelic::Agent.config[:'autostart.blacklisted_executables']) do |bin|
+      def denylisted_executables?
+        denylisted?(NewRelic::Agent.config[:'autostart.denylisted_executables']) do |bin|
           File.basename($0) == bin
         end
       end
@@ -47,18 +52,18 @@ module NewRelic
         !!::NewRelic::LanguageSupport.constantize(const_name)
       end
 
-      def blacklisted?(value, &block)
+      def denylisted?(value, &block)
         value.split(/\s*,\s*/).any?(&block)
       end
 
-      def in_blacklisted_rake_task?
+      def in_denylisted_rake_task?
         tasks = begin
                   ::Rake.application.top_level_tasks
                 rescue => e
-            ::NewRelic::Agent.logger.debug("Not in Rake environment so skipping blacklisted_rake_tasks check: #{e}")
+            ::NewRelic::Agent.logger.debug("Not in Rake environment so skipping denylisted_rake_tasks check: #{e}")
             []
           end
-        !(tasks & ::NewRelic::Agent.config[:'autostart.blacklisted_rake_tasks'].split(/\s*,\s*/)).empty?
+        !(tasks & ::NewRelic::Agent.config[:'autostart.denylisted_rake_tasks'].split(/\s*,\s*/)).empty?
       end
     end
   end

data/lib/new_relic/agent/chained_call.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # This class is used by NewRelic::Agent.set_sql_obfuscator to chain multiple
 # obfuscation blocks when not using the default :replace action

data/lib/new_relic/agent/commands/agent_command.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent

data/lib/new_relic/agent/commands/agent_command_router.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # This class is the central point for dispatching get_agent_commands messages
 # to the various components that actually process them.
@@ -9,7 +9,6 @@
 # like the ThreadProfiler, so it's simpler to just keep it together here.
 
 require 'new_relic/agent/commands/agent_command'
-require 'new_relic/agent/commands/xray_session_collection'
 require 'new_relic/agent/threading/backtrace_service'
 
 module NewRelic
@@ -18,8 +17,7 @@ module NewRelic
       class AgentCommandRouter
         attr_reader :handlers
 
-        attr_accessor :thread_profiler_session, :backtrace_service,
-                      :xray_session_collection
+        attr_accessor :thread_profiler_session, :backtrace_service
 
         def initialize(event_listener=nil)
           @handlers    = Hash.new { |*| Proc.new { |cmd| self.unrecognized_agent_command(cmd) } }
@@ -27,11 +25,9 @@ module NewRelic
           @backtrace_service = Threading::BacktraceService.new(event_listener)
 
           @thread_profiler_session = ThreadProfilerSession.new(@backtrace_service)
-          @xray_session_collection = XraySessionCollection.new(@backtrace_service, event_listener)
 
           @handlers['start_profiler'] = Proc.new { |cmd| thread_profiler_session.handle_start_command(cmd) }
           @handlers['stop_profiler']  = Proc.new { |cmd| thread_profiler_session.handle_stop_command(cmd) }
-          @handlers['active_xray_sessions'] = Proc.new { |cmd| xray_session_collection.handle_active_xray_sessions(cmd) }
 
           if event_listener
             event_listener.subscribe(:before_shutdown, &method(:on_before_shutdown))
@@ -45,20 +41,10 @@ module NewRelic
         def check_for_and_handle_agent_commands
           commands = get_agent_commands
 
-          stop_xray_sessions unless active_xray_command?(commands)
-
           results = invoke_commands(commands)
           new_relic_service.agent_command_results(results) unless results.empty?
         end
 
-        def stop_xray_sessions
-          self.xray_session_collection.stop_all_sessions
-        end
-
-        def active_xray_command?(commands)
-          commands.any? {|command| command.name == 'active_xray_sessions'}
-        end
-
         def on_before_shutdown(*args)
           if self.thread_profiler_session.running?
             self.thread_profiler_session.stop(true)
@@ -67,7 +53,6 @@ module NewRelic
 
         def harvest!
           profiles = []
-          profiles += harvest_from_xray_session_collection
           profiles += harvest_from_thread_profiler_session
           log_profiles(profiles)
           profiles
@@ -76,14 +61,10 @@ module NewRelic
         # We don't currently support merging thread profiles that failed to send
         # back into the AgentCommandRouter, so we just no-op this method.
         # Same with reset! - we don't support asynchronous cancellation of a
-        # running thread profile or X-Ray session currently.
+        # running thread profile currently.
         def merge!(*args); end
         def reset!; end
 
-        def harvest_from_xray_session_collection
-          self.xray_session_collection.harvest_thread_profiles
-        end
-
         def harvest_from_thread_profiler_session
           if self.thread_profiler_session.ready_to_harvest?
             self.thread_profiler_session.stop(true)