newrelic_rpm 6.3.0.355 → 9.2.0

data/lib/new_relic/agent/attributes.rb

@@ -0,0 +1,153 @@
+# 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/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,10 +1,11 @@
-# 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.
+# frozen_string_literal: true
 
 require 'logger'
 require 'fileutils'
 require 'new_relic/agent/hostname'
+require 'new_relic/agent/instrumentation/logger/instrumentation'
 
 module NewRelic
   module Agent
@@ -26,6 +27,17 @@ module NewRelic
         !@log.nil?
       end
 
+      def log_request_headers(uri, headers)
+        return unless enabled? && allowed_endpoint?(uri)
+
+        @log.info("REQUEST HEADERS: #{headers}")
+      rescue StandardError, SystemStackError, SystemCallError => e
+        ::NewRelic::Agent.logger.warn('Failed writing request headers to audit log', e)
+      rescue Exception => e
+        ::NewRelic::Agent.logger.warn('Failed writing request headers to audit log with exception. Re-raising in case of interrupt.', e)
+        raise
+      end
+
       def log_request(uri, data, marshaller)
         return unless enabled? && allowed_endpoint?(uri)
 
@@ -38,9 +50,9 @@ module NewRelic
         @log.info("REQUEST: #{uri}")
         @log.info("REQUEST BODY: #{request_body}")
       rescue StandardError, SystemStackError, SystemCallError => e
-        ::NewRelic::Agent.logger.warn("Failed writing to audit log", e)
+        ::NewRelic::Agent.logger.warn('Failed writing to audit log', e)
       rescue Exception => e
-        ::NewRelic::Agent.logger.warn("Failed writing to audit log with exception. Re-raising in case of interrupt.", e)
+        ::NewRelic::Agent.logger.warn('Failed writing to audit log with exception. Re-raising in case of interrupt.', e)
         raise
       end
 
@@ -52,7 +64,7 @@ module NewRelic
         if wants_stdout?
           # Using $stdout global for easier reassignment in testing
           @log = ::Logger.new($stdout)
-          ::NewRelic::Agent.logger.info("Audit log enabled to STDOUT")
+          ::NewRelic::Agent.logger.info('Audit log enabled to STDOUT')
         elsif path = ensure_log_path
           @log = ::Logger.new(path)
           ::NewRelic::Agent.logger.info("Audit log enabled at '#{path}'")
@@ -60,6 +72,9 @@ module NewRelic
           @log = NewRelic::Agent::NullLogger.new
         end
 
+        # Never have agent log forwarding capture audits
+        NewRelic::Agent::Instrumentation::Logger.mark_skip_instrumenting(@log)
+
         @log.formatter = create_log_formatter
       end
 
@@ -80,13 +95,13 @@ module NewRelic
       end
 
       def wants_stdout?
-        ::NewRelic::Agent.config[:'audit_log.path'].upcase == "STDOUT"
+        ::NewRelic::Agent.config[:'audit_log.path'].casecmp(NewRelic::STANDARD_OUT) == 0
       end
 
       def create_log_formatter
         @hostname = NewRelic::Agent::Hostname.get
         @prefix = wants_stdout? ? '** [NewRelic]' : ''
-        Proc.new do |severity, time, progname, msg|
+        proc do |severity, time, progname, msg|
           "#{@prefix}[#{time} #{@hostname} (#{$$})] : #{msg}\n"
         end
       end

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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -18,47 +18,53 @@ module NewRelic
     module Autostart
       extend self
 
-
       # 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|
-          constant_is_defined?(name)
+      COMMA = ','.freeze
+
+      def denylisted_constants?
+        denylisted?(NewRelic::Agent.config[:'autostart.denylisted_constants']) do |name|
+          if RUBY_PLATFORM.eql?('java')
+            # As of JRuby 9.3.4.0, Object.const_defined? will still cross
+            # namespaces to find constants, which is not what we want. This
+            # behavior is similar to CRuby's Object.const_get prior to v2.6.
+            #
+            # Example:
+            #  irb> class MyClass; end; module MyModule; end
+            #  irb> Object.const_defined?('MyModule::MyClass') # => true
+            !!::NewRelic::LanguageSupport.constantize(name)
+          else
+            Object.const_defined?(name)
+          end
         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
 
-      # Lookup whether namespaced constants (e.g. ::Foo::Bar::Baz) are in the
-      # environment.
-      def constant_is_defined?(const_name)
-        !!::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}")
-            []
-          end
-        !(tasks & ::NewRelic::Agent.config[:'autostart.blacklisted_rake_tasks'].split(/\s*,\s*/)).empty?
+          ::Rake.application.top_level_tasks
+        rescue => e
+          ::NewRelic::Agent.logger.debug("Not in Rake environment so skipping denylisted_rake_tasks check: #{e}")
+          NewRelic::EMPTY_ARRAY
+        end
+        !(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.
+# frozen_string_literal: true
 
 # 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -9,9 +9,9 @@ module NewRelic
         attr_reader :id, :name, :arguments
 
         def initialize(raw_collector_command)
-          @id        = raw_collector_command[0]
-          @name      = raw_collector_command[1]["name"]
-          @arguments = raw_collector_command[1]["arguments"]
+          @id = raw_collector_command[0]
+          @name = raw_collector_command[1]['name']
+          @arguments = raw_collector_command[1]['arguments']
         end
       end
     end

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.
+# frozen_string_literal: true
 
 # 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,22 +17,20 @@ 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) } }
+        def initialize(event_listener = nil)
+          @handlers = Hash.new { |*| proc { |cmd| self.unrecognized_agent_command(cmd) } }
 
           @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) }
+          @handlers['start_profiler'] = proc { |cmd| thread_profiler_session.handle_start_command(cmd) }
+          @handlers['stop_profiler'] = proc { |cmd| thread_profiler_session.handle_stop_command(cmd) }
 
-          if event_listener
+          # the following statement needs else branch coverage
+          if event_listener # rubocop:disable Style/SafeNavigation
             event_listener.subscribe(:before_shutdown, &method(:on_before_shutdown))
           end
         end
@@ -45,20 +42,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 +54,6 @@ module NewRelic
 
         def harvest!
           profiles = []
-          profiles += harvest_from_xray_session_collection
           profiles += harvest_from_thread_profiler_session
           log_profiles(profiles)
           profiles
@@ -76,13 +62,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 reset!; end
 
         def harvest_from_thread_profiler_session
           if self.thread_profiler_session.ready_to_harvest?
@@ -95,17 +78,17 @@ module NewRelic
 
         def log_profiles(profiles)
           if profiles.empty?
-            ::NewRelic::Agent.logger.debug "No thread profiles with data found to send."
+            ::NewRelic::Agent.logger.debug('No thread profiles with data found to send.')
           else
             profile_descriptions = profiles.map { |p| p.to_log_description }
-            ::NewRelic::Agent.logger.debug "Sending thread profiles [#{profile_descriptions.join(", ")}]"
+            ::NewRelic::Agent.logger.debug("Sending thread profiles [#{profile_descriptions.join(', ')}]")
           end
         end
 
         def get_agent_commands
           commands = new_relic_service.get_agent_commands
-          NewRelic::Agent.logger.debug "Received get_agent_commands = #{commands.inspect}"
-          commands.map {|collector_command| AgentCommand.new(collector_command)}
+          NewRelic::Agent.logger.debug("Received get_agent_commands = #{commands.inspect}")
+          commands.map { |collector_command| AgentCommand.new(collector_command) }
         end
 
         def invoke_commands(agent_commands)
@@ -131,15 +114,15 @@ module NewRelic
           end
         end
 
-        SUCCESS_RESULT = {}.freeze
-        ERROR_KEY = "error"
+        SUCCESS_RESULT = NewRelic::EMPTY_HASH
+        ERROR_KEY = 'error'
 
         def success
           SUCCESS_RESULT
         end
 
         def error(err)
-          { ERROR_KEY => err.message }
+          {ERROR_KEY => err.message}
         end
 
         def call_handler_for(agent_command)

data/lib/new_relic/agent/commands/thread_profiler_session.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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/threading/agent_thread'
 require 'new_relic/agent/threading/backtrace_service'
@@ -9,9 +9,7 @@ require 'new_relic/agent/threading/thread_profile'
 module NewRelic
   module Agent
     module Commands
-
       class ThreadProfilerSession
-
         def initialize(backtrace_service)
           @backtrace_service = backtrace_service
           @started_at = nil
@@ -27,31 +25,34 @@ module NewRelic
         end
 
         def handle_stop_command(agent_command)
-          report_data = agent_command.arguments.fetch("report_data", true)
+          report_data = agent_command.arguments.fetch('report_data', true)
           stop(report_data)
         end
 
         def start(agent_command)
-          NewRelic::Agent.logger.debug("Starting Thread Profiler.")
+          NewRelic::Agent.logger.debug('Starting Thread Profiler.')
           profile = @backtrace_service.subscribe(
             NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS,
             agent_command.arguments
           )
 
-          @started_at = Time.now
+          @started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
           @duration = profile.duration if profile
         end
 
         def stop(report_data)
           return unless running?
-          NewRelic::Agent.logger.debug("Stopping Thread Profiler.")
+
+          NewRelic::Agent.logger.debug('Stopping Thread Profiler.')
           @finished_profile = @backtrace_service.harvest(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
           @backtrace_service.unsubscribe(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
           @finished_profile = nil if !report_data
         end
 
         def harvest
-          NewRelic::Agent.logger.debug("Harvesting from Thread Profiler #{@finished_profile.to_log_description unless @finished_profile.nil?}")
+          NewRelic::Agent.logger.debug(
+            "Harvesting from Thread Profiler #{@finished_profile&.to_log_description}"
+          )
           profile = @finished_profile
           @backtrace_service.profile_agent_code = false
           @finished_profile = nil
@@ -72,7 +73,9 @@ module NewRelic
         end
 
         def past_time?
-          @started_at && (Time.now > @started_at + @duration)
+          @started_at && (
+            Process.clock_gettime(Process::CLOCK_REALTIME) > @started_at + @duration
+          )
         end
 
         def stopped?
@@ -86,9 +89,9 @@ module NewRelic
         end
 
         def raise_unsupported_error
-          msg = <<-EOF
-Thread profiling is not supported for Resque processes. If you did not intend to
-profile a Resque process, profiling again might select an appropriate agent.
+          msg = <<~EOF
+            Thread profiling is not supported for Resque processes. If you did not intend to
+            profile a Resque process, profiling again might select an appropriate agent.
           EOF
           raise_command_error(msg)
         end
@@ -99,10 +102,9 @@ profile a Resque process, profiling again might select an appropriate agent.
         end
 
         def raise_already_started_error
-          msg = "Profile already in progress. Ignoring agent command to start another."
+          msg = 'Profile already in progress. Ignoring agent command to start another.'
           raise_command_error(msg)
         end
-
       end
     end
   end