newrelic_rpm 6.8.0.360 → 8.13.1

data/lib/new_relic/agent/agent_logger.rb

@@ -1,23 +1,25 @@
-# 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 'thread'
 require 'logger'
 require 'new_relic/agent/hostname'
 require 'new_relic/agent/log_once'
+require 'new_relic/agent/instrumentation/logger/instrumentation'
 
 module NewRelic
   module Agent
     class AgentLogger
       include LogOnce
 
-      def initialize(root = "", override_logger=nil)
+      def initialize(root = "", override_logger = nil)
         @already_logged_lock = Mutex.new
         clear_already_logged
         create_log(root, override_logger)
         set_log_level!
         set_log_format!
+        disable_log_instrumentation!
 
         gather_startup_logs
       end
@@ -50,8 +52,8 @@ module NewRelic
       # the log level that the backtrace is logged at. If you just want the
       # default behavior of backtraces logged at debug, use one of the methods
       # above and pass an Exception as one of the args.
-      def log_exception(level, e, backtrace_level=level)
-        @log.send(level, "%p: %s" % [ e.class, e.message ])
+      def log_exception(level, e, backtrace_level = level)
+        @log.send(level, "%p: %s" % [e.class, e.message])
         @log.send(backtrace_level) do
           backtrace = backtrace_from_exception(e)
           if backtrace
@@ -72,7 +74,7 @@ module NewRelic
         # We've seen that often the backtrace on a SystemStackError is bunk
         # so massage the caller instead at a known depth.
         #
-        # Tests keep us honest about minmum method depth our log calls add.
+        # Tests keep us honest about minimum method depth our log calls add.
         return caller.drop(5) if e.is_a?(SystemStackError)
 
         e.backtrace
@@ -81,11 +83,9 @@ module NewRelic
       # Allows for passing exceptions in explicitly, which format with backtrace
       def format_and_send(level, *msgs, &block)
         if block
-          if @log.send("#{level}?")
-            msgs = Array(block.call)
-          else
-            msgs = []
-          end
+          return unless @log.send("#{level}?")
+
+          msgs = Array(yield)
         end
 
         msgs.flatten.each do |item|
@@ -132,12 +132,12 @@ module NewRelic
       end
 
       def wants_stdout?
-        ::NewRelic::Agent.config[:log_file_path].upcase == "STDOUT"
+        ::NewRelic::Agent.config[:log_file_path].casecmp(NewRelic::STANDARD_OUT) == 0
       end
 
       def find_or_create_file_path(path_setting, root)
-        for abs_path in [ File.expand_path(path_setting),
-                          File.expand_path(File.join(root, path_setting)) ] do
+        for abs_path in [File.expand_path(path_setting),
+          File.expand_path(File.join(root, path_setting))] do
           if File.directory?(abs_path) || (Dir.mkdir(abs_path) rescue nil)
             return abs_path[%r{^(.*?)/?$}]
           end
@@ -151,10 +151,10 @@ module NewRelic
 
       LOG_LEVELS = {
         "debug" => ::Logger::DEBUG,
-        "info"  => ::Logger::INFO,
-        "warn"  => ::Logger::WARN,
+        "info" => ::Logger::INFO,
+        "warn" => ::Logger::WARN,
         "error" => ::Logger::ERROR,
-        "fatal" => ::Logger::FATAL,
+        "fatal" => ::Logger::FATAL
       }
 
       def self.log_level_for(level)
@@ -164,19 +164,23 @@ module NewRelic
       def set_log_format!
         @hostname = NewRelic::Agent::Hostname.get
         @prefix = wants_stdout? ? '** [NewRelic]' : ''
-        @log.formatter = Proc.new do |severity, timestamp, progname, msg|
+        @log.formatter = proc do |severity, timestamp, progname, msg|
           "#{@prefix}[#{timestamp.strftime("%F %H:%M:%S %z")} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
         end
       end
 
+      # Don't allow agent logs into agent log forwarding for now
+      def disable_log_instrumentation!
+        NewRelic::Agent::Instrumentation::Logger.mark_skip_instrumenting(@log)
+      end
+
       def gather_startup_logs
         StartupLogger.instance.dump(self)
       end
 
-      def self.format_fatal_error message
+      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.
+# frozen_string_literal: true
 
 # This class applies filtering rules as specified in the Agent Attributes
 # cross-agent spec.
@@ -64,64 +64,83 @@ 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_SPAN_EVENTS          = 1 << 4
+      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                  = 0x3f
+      DST_ALL = 0x3f
 
       attr_reader :rules
 
       def initialize(config)
-        @enabled_destinations = DST_NONE
+        prep_enabled_destinations(config)
+        prep_rules(config)
 
-        @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']
+        # We're ok to cache high security for fast lookup because the attribute
+        # filter is re-generated on any significant config change.
+        @high_security = config[:high_security]
+
+        setup_key_cache
+        cache_prefix_denylist
+      end
 
-        @enabled_destinations = DST_NONE unless config[:'attributes.enabled']
+      def prep_enabled_destinations(config)
+        @enabled_destinations = config[:'attributes.enabled'] ? enabled_destinations_for_attributes(config) : DST_NONE
+      end
+
+      def enabled_destinations_for_attributes(config)
+        destinations = DST_NONE
+        destinations |= DST_TRANSACTION_TRACER if config[:'transaction_tracer.attributes.enabled']
+        destinations |= DST_TRANSACTION_EVENTS if config[:'transaction_events.attributes.enabled']
+        destinations |= DST_ERROR_COLLECTOR if config[:'error_collector.attributes.enabled']
+        destinations |= DST_BROWSER_MONITORING if config[:'browser_monitoring.attributes.enabled']
+        destinations |= DST_SPAN_EVENTS if config[:'span_events.attributes.enabled']
+        destinations |= DST_TRANSACTION_SEGMENTS if config[:'transaction_segments.attributes.enabled']
+        destinations
+      end
 
+      def prep_rules(config)
         @rules = []
+        prep_attributes_exclude_rules(config)
+        prep_capture_params_rules(config)
+        prep_datastore_rules(config)
+        prep_attributes_include_rules(config)
+        build_uri_rule(config[:'attributes.exclude'])
+        @rules.sort!
+      end
 
+      def prep_attributes_exclude_rules(config)
         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[:'span_events.attributes.exclude'],          DST_SPAN_EVENTS,          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)
+      end
 
+      def prep_capture_params_rules(config)
         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(['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)
+      end
 
-        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'])
+      def prep_datastore_rules(config)
+        build_rule(%w[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'])
+      end
 
+      def prep_attributes_include_rules(config)
         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[:'span_events.attributes.include'],          DST_SPAN_EVENTS,          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!
-
-        # We're ok to cache high security for fast lookup because the attribute
-        # filter is re-generated on any significant config change.
-        @high_security = config[:high_security]
-
-        setup_key_cache
-        cache_prefix_denylist
       end
 
       # Note the key_cache is a global cache, accessible by multiple threads,
@@ -165,7 +184,7 @@ module NewRelic
       end
 
       def build_uri_rule(excluded_attributes)
-        uri_aliases = %w(uri url request_uri request.uri http.url)
+        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)
@@ -175,7 +194,7 @@ module NewRelic
       def apply(attribute_name, default_destinations)
         return DST_NONE if @enabled_destinations == DST_NONE
 
-        destinations   = default_destinations
+        destinations = default_destinations
         attribute_name = attribute_name.to_s
 
         @rules.each do |rule|
@@ -225,8 +244,8 @@ module NewRelic
       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')
+        @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
@@ -257,9 +276,9 @@ module NewRelic
 
       def initialize(attribute_name, destinations, is_include)
         @attribute_name = attribute_name.sub(/\*$/, "")
-        @wildcard       = attribute_name.end_with?("*")
-        @is_include     = is_include
-        @destinations   = is_include ? destinations : ~destinations
+        @wildcard = attribute_name.end_with?("*")
+        @is_include = is_include
+        @destinations = is_include ? destinations : ~destinations
       end
 
       # Rules are sorted from least specific to most specific

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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -11,19 +11,19 @@ module NewRelic
       EMPTY_ARRAY_STRING_LITERAL = "[]".freeze
 
       def flatten_and_coerce(object, prefix = nil, result = {}, &blk)
-        if object.is_a? Hash
+        if object.is_a?(Hash)
           flatten_and_coerce_hash(object, prefix, result, &blk)
-        elsif object.is_a? Array
+        elsif object.is_a?(Array)
           flatten_and_coerce_array(object, prefix, result, &blk)
         elsif prefix
           val = Coerce.scalar(object)
           if blk
-            blk.call(prefix, val)
+            yield(prefix, val)
           elsif !val.nil?
             result[prefix] = val
           end
         else
-          NewRelic::Agent.logger.warn "Unexpected object: #{object.inspect} with nil prefix passed to NewRelic::Agent::AttributeProcessing.flatten_and_coerce"
+          NewRelic::Agent.logger.warn("Unexpected object: #{object.inspect} with nil prefix passed to NewRelic::Agent::AttributeProcessing.flatten_and_coerce")
         end
         result
       end
@@ -31,7 +31,7 @@ module NewRelic
       def flatten_and_coerce_hash(hash, prefix, result, &blk)
         if hash.empty?
           if blk
-            blk.call(prefix, EMPTY_HASH_STRING_LITERAL)
+            yield(prefix, EMPTY_HASH_STRING_LITERAL)
           else
             result[prefix] = EMPTY_HASH_STRING_LITERAL
           end
@@ -46,7 +46,7 @@ module NewRelic
       def flatten_and_coerce_array(array, prefix, result, &blk)
         if array.empty?
           if blk
-            blk.call(prefix, EMPTY_ARRAY_STRING_LITERAL)
+            yield(prefix, EMPTY_ARRAY_STRING_LITERAL)
           else
             result[prefix] = EMPTY_ARRAY_STRING_LITERAL
           end

data/lib/new_relic/agent/attributes.rb

@@ -1,17 +1,17 @@
-# 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/attribute_processing'
 
 module NewRelic
   module Agent
     class Attributes
-      KEY_LIMIT   = 255
+      KEY_LIMIT = 255
       VALUE_LIMIT = 255
       COUNT_LIMIT = 64
 
-      EMPTY_HASH = {}.freeze
+      attr_reader :custom_attributes
 
       def initialize(filter)
         @filter = filter
@@ -34,7 +34,7 @@ module NewRelic
       end
 
       def add_agent_attribute_with_key_check(key, value, default_destinations)
-        if exceeds_bytesize_limit? key, KEY_LIMIT
+        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
@@ -58,6 +58,7 @@ module NewRelic
       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
@@ -73,10 +74,10 @@ module NewRelic
 
       def intrinsic_attributes_for(destination)
         if destination == NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER ||
-           destination == NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
+            destination == NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
           @intrinsic_attributes
         else
-          EMPTY_HASH
+          NewRelic::EMPTY_HASH
         end
       end
 
@@ -120,7 +121,7 @@ module NewRelic
 
       def for_destination(attributes, calculated_destinations, destination)
         # Avoid allocating anything if there are no attrs at all
-        return EMPTY_HASH if attributes.empty?
+        return NewRelic::EMPTY_HASH if attributes.empty?
 
         attributes.inject({}) do |memo, (key, value)|
           if @filter.allows?(calculated_destinations[key], destination)

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)
 
@@ -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,13 +18,12 @@ module NewRelic
     module Autostart
       extend self
 
-
       # The constants, executables (i.e. $0) and rake tasks used can be
       # configured with the config keys 'autostart.denylisted_constants',
       # 'autostart.denylisted_executables' and
       # 'autostart.denylisted_rake_tasks'
       def agent_should_start?
-          !denylisted_constants? &&
+        !denylisted_constants? &&
           !denylisted_executables? &&
           !in_denylisted_rake_task?
       end
@@ -32,11 +31,19 @@ module NewRelic
       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)
+        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
 
@@ -46,23 +53,17 @@ module NewRelic
         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 denylisted?(value, &block)
         value.split(/\s*,\s*/).any?(&block)
       end
 
       def in_denylisted_rake_task?
         tasks = begin
-                  ::Rake.application.top_level_tasks
-                rescue => e
-            ::NewRelic::Agent.logger.debug("Not in Rake environment so skipping denylisted_rake_tasks check: #{e}")
-            []
-          end
+          ::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

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,8 +9,8 @@ module NewRelic
         attr_reader :id, :name, :arguments
 
         def initialize(raw_collector_command)
-          @id        = raw_collector_command[0]
-          @name      = raw_collector_command[1]["name"]
+          @id = raw_collector_command[0]
+          @name = raw_collector_command[1]["name"]
           @arguments = raw_collector_command[1]["arguments"]
         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.
@@ -19,15 +19,15 @@ module NewRelic
 
         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)
 
-          @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['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
             event_listener.subscribe(:before_shutdown, &method(:on_before_shutdown))
@@ -63,6 +63,7 @@ module NewRelic
         # Same with reset! - we don't support asynchronous cancellation of a
         # running thread profile currently.
         def merge!(*args); end
+
         def reset!; end
 
         def harvest_from_thread_profiler_session
@@ -76,17 +77,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)
@@ -112,7 +113,7 @@ module NewRelic
           end
         end
 
-        SUCCESS_RESULT = {}.freeze
+        SUCCESS_RESULT = NewRelic::EMPTY_HASH
         ERROR_KEY = "error"
 
         def success
@@ -120,7 +121,7 @@ module NewRelic
         end
 
         def error(err)
-          { ERROR_KEY => err.message }
+          {ERROR_KEY => err.message}
         end
 
         def call_handler_for(agent_command)