newrelic_rpm 8.2.0 → 9.0.0

data/lib/new_relic/agent/method_tracer.rb

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 # This file may be independently required to set up method tracing prior to
 # the full agent loading. In those cases, we do need at least this require to
@@ -47,7 +47,6 @@ module NewRelic
     #
 
     module MethodTracer
-
       def self.included(klass)
         klass.extend(ClassMethods)
       end
@@ -68,8 +67,8 @@ module NewRelic
       #
       # @api public
       #
-      def trace_execution_scoped(metric_names, options=NewRelic::EMPTY_HASH) #THREAD_LOCAL_ACCESS
-        NewRelic::Agent.record_api_supportability_metric :trace_execution_scoped unless options[:internal]
+      def trace_execution_scoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
+        NewRelic::Agent.record_api_supportability_metric(:trace_execution_scoped) unless options[:internal]
         NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(metric_names, options) do
           # Using an implicit block avoids object allocation for a &block param
           yield
@@ -84,9 +83,10 @@ module NewRelic
       #
       # @api public
       #
-      def trace_execution_unscoped(metric_names, options=NewRelic::EMPTY_HASH) #THREAD_LOCAL_ACCESS
-        NewRelic::Agent.record_api_supportability_metric :trace_execution_unscoped unless options[:internal]
+      def trace_execution_unscoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
+        NewRelic::Agent.record_api_supportability_metric(:trace_execution_unscoped) unless options[:internal]
         return yield unless NewRelic::Agent.tl_is_execution_traced?
+
         t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         begin
           yield
@@ -101,9 +101,9 @@ module NewRelic
       module ClassMethods
         # contains methods refactored out of the #add_method_tracer method
         module AddMethodTracer
-          ALLOWED_KEYS = [:metric, :push_scope, :code_header, :code_footer].freeze
+          ALLOWED_KEYS = [:metric, :push_scope, :code_header, :code_information, :code_footer].freeze
 
-          DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :code_header => "", :code_footer => "" }.freeze
+          DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :code_header => "", :code_footer => ""}.freeze
 
           # Checks the provided options to make sure that they make
           # sense. Raises an error if the options are incorrect to
@@ -117,7 +117,7 @@ module NewRelic
             unrecognized_keys = options.keys - ALLOWED_KEYS
             if unrecognized_keys.any?
               raise "Unrecognized options when adding method tracer to #{method_name}: " +
-                    unrecognized_keys.join(', ')
+                unrecognized_keys.join(', ')
             end
 
             options = DEFAULT_SETTINGS.merge(options)
@@ -164,7 +164,7 @@ module NewRelic
           # for testing only
           def _nr_clear_traced_methods!
             _nr_traced_method_module.module_eval do
-              self.instance_methods.each { |m| remove_method m }
+              self.instance_methods.each { |m| remove_method(m) }
             end
           end
 
@@ -252,6 +252,7 @@ module NewRelic
         # may get removed as well.
         def remove_method_tracer(method_name) # :nodoc:
           return unless Agent.config[:agent_enabled]
+
           if _nr_traced_method_module.method_defined?(method_name)
             _nr_traced_method_module.send(:remove_method, method_name)
             ::NewRelic::Agent.logger.debug("removed method tracer #{method_name}\n")
@@ -265,22 +266,24 @@ module NewRelic
         def _nr_add_method_tracer_now(method_name, metric_name, options)
           NewRelic::Agent.record_api_supportability_metric(:add_method_tracer)
           return unless newrelic_method_exists?(method_name)
+
           remove_method_tracer(method_name) if method_traced?(method_name)
 
           options = _nr_validate_method_tracer_options(method_name, options)
 
-          visibility = NewRelic::Helper.instance_method_visibility self, method_name
+          visibility = NewRelic::Helper.instance_method_visibility(self, method_name)
 
           scoped_metric, unscoped_metrics = _nr_scoped_unscoped_metrics(metric_name, method_name, push_scope: options[:push_scope])
 
           _nr_define_traced_method(method_name, scoped_metric: scoped_metric, unscoped_metrics: unscoped_metrics,
-                                   code_header: options[:code_header], code_footer: options[:code_footer],
-                                   record_metrics: options[:metric], visibility: visibility)
+            code_header: options[:code_header], code_footer: options[:code_footer],
+            record_metrics: options[:metric], visibility: visibility,
+            code_information: options[:code_information])
 
           prepend(_nr_traced_method_module)
 
-          ::NewRelic::Agent.logger.debug("Traced method: class = #{_nr_derived_class_name},"+
-                                         "method = #{method_name}, "+
+          ::NewRelic::Agent.logger.debug("Traced method: class = #{_nr_derived_class_name}," +
+                                         "method = #{method_name}, " +
                                          "metric = '#{metric_name}'")
         end
 
@@ -298,11 +301,13 @@ module NewRelic
         end
 
         def _nr_define_traced_method(method_name, scoped_metric: nil, unscoped_metrics: [],
-                                     code_header: nil, code_footer: nil, record_metrics: true,
-                                     visibility: :public)
+          code_header: nil, code_footer: nil, record_metrics: true,
+          visibility: :public, code_information: {})
+
           _nr_traced_method_module.module_eval do
             define_method(method_name) do |*args, &block|
               return super(*args, &block) unless NewRelic::Agent.tl_is_execution_traced?
+
               scoped_metric_eval, unscoped_metrics_eval = nil, []
 
               scoped_metric_eval = case scoped_metric
@@ -310,9 +315,7 @@ module NewRelic
                   instance_exec(*args, &scoped_metric)
                 when String
                   scoped_metric
-                else
-                  nil
-                end
+              end
 
               unscoped_metrics_eval = unscoped_metrics.map do |metric|
                 metric.kind_of?(Proc) ? instance_exec(*args, &metric) : metric.to_s
@@ -328,7 +331,10 @@ module NewRelic
               # If tracing multiple metrics on this method, nest one unscoped trace inside the scoped trace.
               begin
                 if scoped_metric_eval
-                  ::NewRelic::Agent::MethodTracer.trace_execution_scoped(scoped_metric_eval, metric: record_metrics, internal: true) do
+                  ::NewRelic::Agent::MethodTracer.trace_execution_scoped(scoped_metric_eval,
+                    metric: record_metrics,
+                    internal: true,
+                    code_information: code_information) do
                     if unscoped_metrics_eval.empty?
                       super(*args, &block)
                     else
@@ -347,7 +353,7 @@ module NewRelic
               end
             end
 
-            send visibility, method_name
+            send(visibility, method_name)
             ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
           end
         end

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -1,20 +1,26 @@
-# 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module MethodTracerHelpers
+      # These are code level metrics (CLM) attributes. For Ruby, they map like so:
+      #   filepath: full path to an .rb file on disk
+      #   lineno: the line number a Ruby method is defined on within a given .rb file
+      #   function: the name of the Ruby method
+      #   namespace: the Ruby class' namespace as a string, ex: 'MyModule::MyClass'
+      SOURCE_CODE_INFORMATION_PARAMETERS = %i[filepath lineno function namespace].freeze
+      SOURCE_CODE_INFORMATION_FAILURE_METRIC = "Supportability/CodeLevelMetrics/Ruby/Failure".freeze
       MAX_ALLOWED_METRIC_DURATION = 1_000_000_000 # roughly 31 years
 
       extend self
 
-      def trace_execution_scoped(metric_names, options=NewRelic::EMPTY_HASH) #THREAD_LOCAL_ACCESS
-        state = NewRelic::Agent::Tracer.state
-        return yield unless state.is_execution_traced?
+      def trace_execution_scoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
+        return yield unless NewRelic::Agent::Tracer.state.is_execution_traced?
 
         metric_names = Array(metric_names)
-        first_name   = metric_names.shift
+        first_name = metric_names.shift
         return yield unless first_name
 
         segment = NewRelic::Agent::Tracer.start_segment(
@@ -22,15 +28,86 @@ module NewRelic
           unscoped_metrics: metric_names
         )
 
-        if options[:metric] == false
-          segment.record_metrics = false
+        segment.record_metrics = false if options[:metric] == false
+
+        unless !options.key?(:code_information) || options[:code_information].nil? || options[:code_information].empty?
+          segment.code_information = options[:code_information]
         end
 
-        begin
-          Tracer.capture_segment_error(segment) { yield }
-        ensure
-          segment.finish if segment
+        Tracer.capture_segment_error(segment) { yield }
+      ensure
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
+      end
+
+      def code_information(object, method_name)
+        return ::NewRelic::EMPTY_HASH unless clm_enabled? && object && method_name
+
+        @code_information ||= {}
+        cache_key = "#{object.object_id}#{method_name}".freeze
+        return @code_information[cache_key] if @code_information.key?(cache_key)
+
+        namespace, location, is_class_method = namespace_and_location(object, method_name.to_sym)
+
+        @code_information[cache_key] = {filepath: location.first,
+                                        lineno: location.last,
+                                        function: "#{'self.' if is_class_method}#{method_name}",
+                                        namespace: namespace}.freeze
+      rescue => e
+        ::NewRelic::Agent.logger.warn("Unable to determine source code info for '#{object}', " \
+                                        "method '#{method_name}' - #{e.class}: #{e.message}")
+        ::NewRelic::Agent.increment_metric(SOURCE_CODE_INFORMATION_FAILURE_METRIC, 1)
+        ::NewRelic::EMPTY_HASH
+      end
+
+      private
+
+      def clm_enabled?
+        ::NewRelic::Agent.config[:'code_level_metrics.enabled']
+      end
+
+      # The string representation of a singleton class looks like
+      # '#<Class:MyModule::MyClass>'. Return the 'MyModule::MyClass' part of
+      # that string
+      def klass_name(object)
+        name = Regexp.last_match(1) if object.to_s =~ /^#<Class:(.*)>$/
+        return name if name
+
+        raise "Unable to glean a class name from string '#{object}'"
+      end
+
+      # get at the underlying class from the singleton class
+      #
+      # note: even with the regex hit from klass_name(), `Object.const_get`
+      # is more performant than iterating through `ObjectSpace`
+      def klassify_singleton(object)
+        Object.const_get(klass_name(object))
+      end
+
+      # determine the namespace (class name including all module names in scope)
+      # and source code location (file path and line number) for the given
+      # object and method name
+      #
+      # traced class methods:
+      #     * object is a singleton class, `#<Class::MyClass>`
+      #     * get at the underlying non-singleton class
+      #
+      # traced instance methods and Rails controller methods:
+      #     * object is a class, `MyClass`
+      #
+      # anonymous class based methods (`c = Class.new { def method; end; }`:
+      #     * `#name` returns `nil`, so use '(Anonymous)' instead
+      #
+      def namespace_and_location(object, method_name)
+        klass = object.singleton_class? ? klassify_singleton(object) : object
+        name = klass.name || '(Anonymous)'
+        is_class_method = false
+        method = if (klass.instance_methods + klass.private_instance_methods).include?(method_name)
+          klass.instance_method(method_name)
+        else
+          is_class_method = true
+          klass.method(method_name)
         end
+        [name, method.source_location, is_class_method]
       end
     end
   end

data/lib/new_relic/agent/monitors/cross_app_monitor.rb

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 require 'digest'
 require 'json'
@@ -12,13 +12,11 @@ module NewRelic
   module Agent
     module DistributedTracing
       class CrossAppMonitor < InboundRequestMonitor
-
-        NEWRELIC_ID_HEADER      = 'X-NewRelic-ID'.freeze
-        NEWRELIC_TXN_HEADER     = 'X-NewRelic-Transaction'.freeze
+        NEWRELIC_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
         NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
 
-        NEWRELIC_ID_HEADER_KEY    = 'HTTP_X_NEWRELIC_ID'.freeze
-        NEWRELIC_TXN_HEADER_KEY   = 'HTTP_X_NEWRELIC_TRANSACTION'.freeze
+        NEWRELIC_ID_HEADER_KEY = 'HTTP_X_NEWRELIC_ID'.freeze
+        NEWRELIC_TXN_HEADER_KEY = 'HTTP_X_NEWRELIC_TRANSACTION'.freeze
         CONTENT_LENGTH_HEADER_KEY = 'HTTP_CONTENT_LENGTH'.freeze
 
         def on_finished_configuring(events)
@@ -33,8 +31,8 @@ module NewRelic
         end
 
         def path_hash(txn_name, seed)
-          rotated    = ((seed << 1) | (seed >> 31)) & 0xffffffff
-          app_name   = NewRelic::Agent.config[:app_name].first
+          rotated = ((seed << 1) | (seed >> 31)) & 0xffffffff
+          app_name = NewRelic::Agent.config[:app_name].first
           identifier = "#{app_name};#{txn_name}"
           sprintf("%08x", rotated ^ hash_transaction_name(identifier))
         end
@@ -45,10 +43,10 @@ module NewRelic
         #   :before_call will save our cross application request id to the thread
         #   :after_call will write our response headers/metrics and clean up the thread
         def register_event_listeners(events)
-          NewRelic::Agent.logger.
-            debug("Wiring up Cross Application Tracing to events after finished configuring")
+          NewRelic::Agent.logger
+            .debug("Wiring up Cross Application Tracing to events after finished configuring")
 
-          events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
+          events.subscribe(:before_call) do |env| # THREAD_LOCAL_ACCESS
             if id = decoded_id(env) and should_process_request?(id)
               state = NewRelic::Agent::Tracer.state
 
@@ -59,11 +57,11 @@ module NewRelic
                 txn.distributed_tracer.cross_app_payload = payload
               end
 
-              CrossAppTracing.assign_intrinsic_transaction_attributes state
+              CrossAppTracing.assign_intrinsic_transaction_attributes(state)
             end
           end
 
-          events.subscribe(:after_call) do |env, (_status_code, headers, _body)| #THREAD_LOCAL_ACCESS
+          events.subscribe(:after_call) do |env, (_status_code, headers, _body)| # THREAD_LOCAL_ACCESS
             state = NewRelic::Agent::Tracer.state
 
             insert_response_header(state, env, headers)
@@ -85,21 +83,23 @@ module NewRelic
           end
         end
 
-        def should_process_request? id
+        def should_process_request?(id)
           CrossAppTracing.cross_app_enabled? && CrossAppTracing.trusts?(id)
         end
 
         def set_response_headers(transaction, response_headers, content_length)
           payload = obfuscator.obfuscate(
             ::JSON.dump(
-              transaction.distributed_tracer.cross_app_payload.as_json_array(content_length)))
+              transaction.distributed_tracer.cross_app_payload.as_json_array(content_length)
+            )
+          )
 
           response_headers[NEWRELIC_APPDATA_HEADER] = payload
         end
 
         def decoded_id(request)
           encoded_id = request[NEWRELIC_ID_HEADER_KEY]
-          return "" if encoded_id.nil? || encoded_id.empty?
+          return NewRelic::EMPTY_STR if encoded_id.nil? || encoded_id.empty?
 
           obfuscator.deobfuscate(encoded_id)
         end

data/lib/new_relic/agent/monitors/distributed_tracing_monitor.rb

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -8,20 +8,21 @@ module NewRelic
       class Monitor < InboundRequestMonitor
         def on_finished_configuring(events)
           return unless NewRelic::Agent.config[:'distributed_tracing.enabled']
+
           events.subscribe(:before_call, &method(:on_before_call))
         end
 
         def on_before_call(request)
           unless NewRelic::Agent.config[:'distributed_tracing.enabled']
-            NewRelic::Agent.logger.warn "Not configured to accept distributed trace headers" 
+            NewRelic::Agent.logger.warn("Not configured to accept distributed trace headers")
             return
           end
 
           return unless txn = Tracer.current_transaction
 
-          txn.distributed_tracer.accept_incoming_request request
+          txn.distributed_tracer.accept_incoming_request(request)
         end
       end
     end
   end
-end
+end

data/lib/new_relic/agent/monitors/inbound_request_monitor.rb

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 # This class serves as the base for objects wanting to monitor and respond to
 # incoming web requests. Examples include cross application tracing and
@@ -16,7 +16,6 @@ require 'json'
 module NewRelic
   module Agent
     class InboundRequestMonitor
-
       attr_reader :obfuscator
 
       def initialize(events)

data/lib/new_relic/agent/monitors/synthetics_monitor.rb

@@ -1,11 +1,11 @@
-# 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class SyntheticsMonitor < InboundRequestMonitor
-      SYNTHETICS_HEADER_KEY  = 'HTTP_X_NEWRELIC_SYNTHETICS'.freeze
+      SYNTHETICS_HEADER_KEY = 'HTTP_X_NEWRELIC_SYNTHETICS'.freeze
 
       SUPPORTED_VERSION = 1
       EXPECTED_PAYLOAD_LENGTH = 5
@@ -14,7 +14,7 @@ module NewRelic
         events.subscribe(:before_call, &method(:on_before_call))
       end
 
-      def on_before_call(request) #THREAD_LOCAL_ACCESS
+      def on_before_call(request) # THREAD_LOCAL_ACCESS
         encoded_header = request[SYNTHETICS_HEADER_KEY]
         return unless encoded_header
 
@@ -27,11 +27,10 @@ module NewRelic
 
         txn = Tracer.current_transaction
         txn.raw_synthetics_header = encoded_header
-        txn.synthetics_payload    = incoming_payload
+        txn.synthetics_payload = incoming_payload
       end
 
       class << self
-
         def is_supported_version?(incoming_payload)
           incoming_payload.first == SUPPORTED_VERSION
         end
@@ -45,12 +44,10 @@ module NewRelic
           incoming_payload.length == EXPECTED_PAYLOAD_LENGTH
         end
 
-        def reject_messaging_synthetics_header headers
-          headers.reject {|k,_| k == CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER}
+        def reject_messaging_synthetics_header(headers)
+          headers.reject { |k, _| k == CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER }
         end
-
       end
-
     end
   end
 end

data/lib/new_relic/agent/monitors.rb

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 require_relative 'monitors/inbound_request_monitor'
 
@@ -16,12 +16,11 @@ module NewRelic
       attr_reader :synthetics_monitor
       attr_reader :distributed_tracing_monitor
 
-      def initialize events
-        @synthetics_monitor = NewRelic::Agent::SyntheticsMonitor.new events
-        @cross_app_monitor = NewRelic::Agent::DistributedTracing::CrossAppMonitor.new events
-        @distributed_tracing_monitor = NewRelic::Agent::DistributedTracing::Monitor.new events
+      def initialize(events)
+        @synthetics_monitor = NewRelic::Agent::SyntheticsMonitor.new(events)
+        @cross_app_monitor = NewRelic::Agent::DistributedTracing::CrossAppMonitor.new(events)
+        @distributed_tracing_monitor = NewRelic::Agent::DistributedTracing::Monitor.new(events)
       end
-
     end
   end
-end
+end

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

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 require 'base64'
 require 'json'
@@ -12,14 +12,14 @@ module NewRelic
     class NewRelicService
       module Encoders
         module Identity
-          def self.encode(data, opts=nil)
+          def self.encode(data, opts = nil)
             data
           end
         end
 
         module Compressed
           module Deflate
-            def self.encode(data, opts=nil)
+            def self.encode(data, opts = nil)
               Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
             end
           end
@@ -27,9 +27,9 @@ module NewRelic
           module Gzip
             BINARY = "BINARY".freeze
 
-            def self.encode(data, opts=nil)
+            def self.encode(data, opts = nil)
               output = StringIO.new
-              output.set_encoding BINARY
+              output.set_encoding(BINARY)
               gz = Zlib::GzipWriter.new(output, Zlib::DEFAULT_COMPRESSION, Zlib::DEFAULT_STRATEGY)
               gz.write(data)
               gz.close
@@ -40,7 +40,7 @@ module NewRelic
         end
 
         module Base64CompressedJSON
-          def self.encode(data, opts={})
+          def self.encode(data, opts = {})
             if !opts[:skip_normalization] && Agent.config[:normalize_json_string_encodings]
               data = NewRelic::Agent::EncodingNormalizer.normalize_object(data)
             end

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

@@ -1,6 +1,6 @@
-# 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.
+# frozen_string_literal: true
 
 require 'json'
 require 'new_relic/agent/new_relic_service/marshaller'
@@ -20,14 +20,14 @@ module NewRelic
           if defined?(::Yajl)
             require 'yajl/version'
             if Gem::Version.new(::Yajl::VERSION) < OK_YAJL_VERSION
-              ::NewRelic::Agent.logger.warn "Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with newrelic_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available."
+              ::NewRelic::Agent.logger.warn("Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with newrelic_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available.")
             end
           end
         rescue => err
-          ::NewRelic::Agent.logger.warn "Failed trying to watch for problematic yajl-ruby version.", err
+          ::NewRelic::Agent.logger.warn("Failed trying to watch for problematic yajl-ruby version.", err)
         end
 
-        def dump(ruby, opts={})
+        def dump(ruby, opts = {})
           prepared = prepare(ruby, opts)
 
           if !opts[:skip_normalization] && Agent.config[:normalize_json_string_encodings]
@@ -44,7 +44,7 @@ module NewRelic
 
           return_value(::JSON.load(data))
         rescue => e
-          ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
+          ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} encountered loading collector response: #{data}")
           raise
         end
 

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

@@ -1,12 +1,12 @@
-# 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class NewRelicService
       class Marshaller
-        def prepare(data, options={})
+        def prepare(data, options = {})
           encoder = options[:encoder] || default_encoder
           if data.respond_to?(:to_collector_array)
             data.to_collector_array(encoder)

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

@@ -1,12 +1,12 @@
-# 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class NewRelicService
       module SecurityPolicySettings
-        EXPECTED_SECURITY_POLICIES = %w(
+        EXPECTED_SECURITY_POLICIES = %w[
           record_sql
           attributes_include
           allow_raw_exception_messages
@@ -14,12 +14,12 @@ module NewRelic
           custom_parameters
           custom_instrumentation_editor
           message_parameters
-          job_arguments).map(&:freeze)
+        ].map(&:freeze)
 
         def self.preliminary_settings(security_policies)
           enabled_key = 'enabled'.freeze
           settings = EXPECTED_SECURITY_POLICIES.inject({}) do |memo, policy_name|
-            memo[policy_name] =  {enabled_key => security_policies[policy_name][enabled_key]}
+            memo[policy_name] = {enabled_key => security_policies[policy_name][enabled_key]}
             memo
           end
           {'security_policies' => settings}