newrelic_rpm 9.7.0 → 9.16.1

data/lib/new_relic/agent/tracer.rb

@@ -392,11 +392,11 @@ module NewRelic
         #
         # If ever exposed, this requires additional synchronization
         def state_for(thread)
-          state = thread[:newrelic_tracer_state]
+          state = ThreadLocalStorage.get(thread, :newrelic_tracer_state)
 
           if state.nil?
             state = Tracer::State.new
-            thread[:newrelic_tracer_state] = state
+            ThreadLocalStorage.set(thread, :newrelic_tracer_state, state)
           end
 
           state
@@ -405,7 +405,7 @@ module NewRelic
         alias_method :tl_state_for, :state_for
 
         def clear_state
-          Thread.current[:newrelic_tracer_state] = nil
+          ThreadLocalStorage[:newrelic_tracer_state] = nil
         end
 
         alias_method :tl_clear, :clear_state
@@ -420,12 +420,12 @@ module NewRelic
 
         def thread_block_with_current_transaction(segment_name: nil, parent: nil, &block)
           parent ||= current_segment
-          current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
+          current_txn = ThreadLocalStorage[:newrelic_tracer_state]&.current_transaction if ThreadLocalStorage[:newrelic_tracer_state]&.is_execution_traced?
           proc do |*args|
             begin
               if current_txn && !current_txn.finished?
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn
-                ::Thread.current[:newrelic_thread_span_parent] = parent
+                ThreadLocalStorage[:newrelic_thread_span_parent] = parent
                 current_txn.async = true
                 segment_name = "#{segment_name}/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
                 segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent) if segment_name

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -20,7 +20,7 @@ module NewRelic
         # calculation in all other cases.
         #
         attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key
-        attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
+        attr_accessor :name, :parent, :children_time, :transaction, :transaction_name, :llm_event
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 

data/lib/new_relic/agent/transaction/external_request_segment.rb

@@ -23,7 +23,6 @@ module NewRelic
         MISSING_STATUS_CODE = 'MissingHTTPStatusCode'
 
         attr_reader :library, :uri, :procedure, :http_status_code
-        attr_writer :record_agent_attributes
 
         def initialize(library, uri, procedure, start_time = nil) # :nodoc:
           @library = library
@@ -32,7 +31,6 @@ module NewRelic
           @host_header = nil
           @app_data = nil
           @http_status_code = nil
-          @record_agent_attributes = false
           super(nil, nil, start_time)
         end
 
@@ -44,14 +42,6 @@ module NewRelic
           @host_header || uri.host
         end
 
-        # By default external request segments only have errors and the http
-        # url recorded as agent attributes. To have all the agent attributes
-        # recorded, use the attr_writer like so `segment.record_agent_attributes = true`
-        # See: SpanEventPrimitive#for_external_request_segment
-        def record_agent_attributes?
-          @record_agent_attributes
-        end
-
         # This method adds New Relic request headers to a given request made to an
         # external API and checks to see if a host header is used for the request.
         # If a host header is used, it updates the segment name to match the host

data/lib/new_relic/agent/transaction/request_attributes.rb

@@ -24,7 +24,7 @@ module NewRelic
           @referer = referer_from_request(request)
           @accept = attribute_from_env(request, HTTP_ACCEPT_HEADER_KEY)
           @content_length = content_length_from_request(request)
-          @content_type = attribute_from_request(request, :content_type)
+          @content_type = content_type_attribute_from_request(request)
           @host = attribute_from_request(request, :host)
           @port = port_from_request(request)
           @user_agent = attribute_from_request(request, :user_agent)
@@ -127,6 +127,18 @@ module NewRelic
           end
         end
 
+        def content_type_attribute_from_request(request)
+          # Rails 7.0 changed the behavior of `content_type`. We want just the MIME type, so use `media_type` if available.
+          # https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#actiondispatch-request-content-type-now-returns-content-type-header-as-it-is
+          content_type = if request.respond_to?(:media_type)
+            :media_type
+          elsif request.respond_to?(:content_type)
+            :content_type
+          end
+
+          request.send(content_type) if content_type
+        end
+
         def attribute_from_env(request, key)
           if env = attribute_from_request(request, :env)
             env[key]

data/lib/new_relic/agent/transaction/trace_context.rb

@@ -95,7 +95,7 @@ module NewRelic
 
         def create_trace_state_payload
           unless Agent.config[:'distributed_tracing.enabled']
-            NewRelic::Agent.logger.warn('Not configured to create WC3 trace context payload')
+            NewRelic::Agent.logger.warn('Not configured to create W3C trace context payload')
             return
           end
 

data/lib/new_relic/agent/transaction/tracing.rb

@@ -41,11 +41,11 @@ module NewRelic
 
         def thread_starting_span
           # if the previous current segment was in another thread, use the thread local parent
-          if ::Thread.current[:newrelic_thread_span_parent] &&
+          if ThreadLocalStorage[:newrelic_thread_span_parent] &&
               current_segment &&
               current_segment.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
 
-            ::Thread.current[:newrelic_thread_span_parent]
+            ThreadLocalStorage[:newrelic_thread_span_parent]
           end
         end
 

data/lib/new_relic/agent/transaction.rb

@@ -816,13 +816,9 @@ module NewRelic
       end
 
       def had_error_affecting_apdex?
-        @exceptions.each do |exception, options|
-          ignored = NewRelic::Agent.instance.error_collector.error_is_ignored?(exception)
-          expected = options[:expected]
-
-          return true unless ignored || expected
+        @exceptions.each.any? do |exception, options|
+          NewRelic::Agent.instance.error_collector.error_affects_apdex?(exception, options)
         end
-        false
       end
 
       def apdex_bucket(duration, current_apdex_t)

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -16,26 +16,27 @@ module NewRelic
     module TransactionErrorPrimitive
       extend self
 
-      SAMPLE_TYPE = 'TransactionError'.freeze
-      TYPE_KEY = 'type'.freeze
-      ERROR_CLASS_KEY = 'error.class'.freeze
-      ERROR_MESSAGE_KEY = 'error.message'.freeze
-      ERROR_EXPECTED_KEY = 'error.expected'.freeze
-      TIMESTAMP_KEY = 'timestamp'.freeze
-      PORT_KEY = 'port'.freeze
-      NAME_KEY = 'transactionName'.freeze
-      DURATION_KEY = 'duration'.freeze
-      SAMPLED_KEY = 'sampled'.freeze
-      GUID_KEY = 'nr.transactionGuid'.freeze
-      REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
-      SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'.freeze
-      SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'.freeze
-      SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'.freeze
+      SAMPLE_TYPE = 'TransactionError'
+      TYPE_KEY = 'type'
+      ERROR_CLASS_KEY = 'error.class'
+      ERROR_MESSAGE_KEY = 'error.message'
+      ERROR_EXPECTED_KEY = 'error.expected'
+      TIMESTAMP_KEY = 'timestamp'
+      PORT_KEY = 'port'
+      NAME_KEY = 'transactionName'
+      DURATION_KEY = 'duration'
+      SAMPLED_KEY = 'sampled'
+      CAT_GUID_KEY = 'nr.transactionGuid'
+      CAT_REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'
+      SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'
+      SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'
+      SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'
       SYNTHETICS_TYPE_KEY = 'nr.syntheticsType'
       SYNTHETICS_INITIATOR_KEY = 'nr.syntheticsInitiator'
       SYNTHETICS_KEY_PREFIX = 'nr.synthetics'
-      PRIORITY_KEY = 'priority'.freeze
-      SPAN_ID_KEY = 'spanId'.freeze
+      PRIORITY_KEY = 'priority'
+      SPAN_ID_KEY = 'spanId'
+      GUID_KEY = 'guid'
 
       SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
 
@@ -57,7 +58,10 @@ module NewRelic
         }
 
         attrs[SPAN_ID_KEY] = span_id if span_id
+        # don't use safe navigation - leave off keys with missing values
+        # instead of using nil
         attrs[PORT_KEY] = noticed_error.request_port if noticed_error.request_port
+        attrs[GUID_KEY] = noticed_error.transaction_id if noticed_error.transaction_id
 
         if payload
           attrs[NAME_KEY] = payload[:name]
@@ -93,8 +97,8 @@ module NewRelic
       end
 
       def append_cat(payload, sample)
-        sample[GUID_KEY] = payload[:guid] if payload[:guid]
-        sample[REFERRING_TRANSACTION_GUID_KEY] = payload[:referring_transaction_guid] if payload[:referring_transaction_guid]
+        sample[CAT_GUID_KEY] = payload[:guid] if payload[:guid]
+        sample[CAT_REFERRING_TRANSACTION_GUID_KEY] = payload[:referring_transaction_guid] if payload[:referring_transaction_guid]
       end
     end
   end

data/lib/new_relic/agent.rb

@@ -31,6 +31,7 @@ module NewRelic
     require 'new_relic/noticed_error'
     require 'new_relic/agent/noticeable_error'
     require 'new_relic/supportability_helper'
+    require 'new_relic/thread_local_storage'
 
     require 'new_relic/agent/encoding_normalizer'
     require 'new_relic/agent/stats'
@@ -62,6 +63,8 @@ module NewRelic
     require 'new_relic/agent/attribute_processing'
     require 'new_relic/agent/linking_metadata'
     require 'new_relic/agent/local_log_decorator'
+    require 'new_relic/agent/llm'
+    require 'new_relic/agent/aws'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -82,6 +85,10 @@ module NewRelic
     # An exception that forces an agent to stop reporting until its mongrel is restarted.
     class ForceDisconnectException < StandardError; end
 
+    # Error handling for the automated custom instrumentation tracer logic
+    class AutomaticTracerParseException < StandardError; end
+    class AutomaticTracerTraceException < StandardError; end
+
     # An exception that forces an agent to restart.
     class ForceRestartException < StandardError
       def message
@@ -105,11 +112,17 @@ module NewRelic
 
     # placeholder name used when we cannot determine a transaction's name
     UNKNOWN_METRIC = '(unknown)'.freeze
+    LLM_FEEDBACK_MESSAGE = 'LlmFeedbackMessage'
+    # give the observed app time to load the code that automatic tracers have
+    # been configured for
+    AUTOMATIC_TRACER_MAX_ATTEMPTS = 60 # 60 = try about twice a second for 30 seconds
 
     attr_reader :error_group_callback
+    attr_reader :llm_token_count_callback
 
     @agent = nil
     @error_group_callback = nil
+    @llm_token_count_callback = nil
     @logger = nil
     @tracer_lock = Mutex.new
     @tracer_queue = []
@@ -119,8 +132,8 @@ module NewRelic
     def agent # :nodoc:
       return @agent if @agent
 
-      NewRelic::Agent.logger.warn("Agent unavailable as it hasn't been started.")
-      NewRelic::Agent.logger.warn(caller.join("\n"))
+      NewRelic::Agent.logger.debug("Agent unavailable as it hasn't been started.")
+      NewRelic::Agent.logger.debug(caller.join("\n"))
       nil
     end
 
@@ -157,6 +170,92 @@ module NewRelic
       end
     end
 
+    # @api private
+    def self.add_automatic_method_tracers(arr)
+      return unless arr
+      return arr if arr.respond_to?(:empty?) && arr.empty?
+
+      arr = arr.split(/\s*,\s*/) if arr.is_a?(String)
+
+      add_tracers_once_methods_are_defined(arr.dup)
+
+      arr
+    end
+
+    # spawn a thread that will attempt to establish a tracer for each of the
+    # configured methods. the thread will continue to keep trying with each
+    # tracer until one of the following happens:
+    #   - the tracer is successfully established
+    #   - the configured method string couldn't be parsed
+    #   - establishing a tracer for a successfully parsed string failed
+    #   - the maximum number of attempts has been reached
+    # the thread will only be spawned once per agent initialization, to account
+    # for configuration reloading scenarios.
+    #
+    # @api private
+    def self.add_tracers_once_methods_are_defined(notations)
+      # this class method can be invoked multiple times at agent startup, so
+      # we return asap here instead of using a traditional memoization of
+      # waiting for the method's body to finish being executed
+      if defined?(@add_tracers_once_methods_are_defined)
+        return
+      else
+        @add_tracers_once_methods_are_defined = true
+      end
+
+      Thread.new do
+        AUTOMATIC_TRACER_MAX_ATTEMPTS.times do
+          notations.delete_if { |notation| prep_tracer_for(notation) }
+
+          break if notations.empty?
+
+          sleep 0.5
+        end
+      end
+    end
+
+    # returns `true` if the notation string has either been successfully
+    # processed or raised an error during processing. returns `false` if the
+    # string seems good but the (customer) code to be traced has not yet been
+    # loaded into the Ruby VM
+    #
+    # @api private
+    def self.prep_tracer_for(fully_qualified_method_notation)
+      delimiters = fully_qualified_method_notation.scan(/\.|#/)
+      raise AutomaticTracerParseException.new("Expected exactly one '.' or '#' delimiter.") unless delimiters.size == 1
+
+      delimiter = delimiters.first
+      namespace, method_name = fully_qualified_method_notation.split(delimiter)
+      unless namespace && !namespace.empty?
+        raise AutomaticTracerParseException.new("Nothing found to the left of the #{delimiter} delimiter.")
+      end
+      unless method_name && !method_name.empty?
+        raise AutomaticTracerParseException.new("Nothing found to the right of the #{delimiter} delimiter.")
+      end
+
+      begin
+        klass = ::NewRelic::LanguageSupport.constantize(namespace)
+        return false unless klass
+
+        klass_to_trace = delimiter.eql?('.') ? klass.singleton_class : klass
+        add_or_defer_method_tracer(klass_to_trace, method_name, nil, {})
+      rescue StandardError => e
+        raise AutomaticTracerTraceException.new("#{e.class} - #{e.message}")
+      end
+
+      true
+    rescue AutomaticTracerParseException => e
+      NewRelic::Agent.logger.error('Unable to parse out a usable method name to trace. Expected a valid, fully ' \
+                                   "qualified method notation. Got: '#{fully_qualified_method_notation}'. " \
+                                   "Error: #{e.message}")
+      true
+    rescue AutomaticTracerTraceException => e
+      NewRelic::Agent.logger.error('Unable to automatically apply a tracer to method ' \
+                                   "'#{fully_qualified_method_notation}'. Error: #{e.message}")
+      true
+    end
+
+    # @api private
     def add_deferred_method_tracers_now
       @tracer_lock.synchronize do
         @tracer_queue.each do |receiver, method_name, metric_name, options|
@@ -387,6 +486,92 @@ module NewRelic
       nil
     end
 
+    # Records user feedback events for LLM applications. This API must pass
+    # the current trace id as a parameter, which can be obtained using:
+    #
+    #   NewRelic::Agent::Tracer.current_trace_id
+    #
+    # @param [String] ID of the trace where the chat completion(s) related
+    #   to the feedback occurred.
+    #
+    # @param [String or Integer] Rating provided by an end user
+    #   (ex: “Good", "Bad”, 1, 2, 5, 8, 10).
+    #
+    # @param [optional, String] Category of the feedback as provided by the
+    #   end user (ex: “informative”, “inaccurate”).
+    #
+    # @param start_time [optional, String] Freeform text feedback from an
+    #   end user.
+    #
+    # @param [optional, Hash] Set of key-value pairs to store any other
+    #   desired data to submit with the feedback event.
+    #
+    # @api public
+    #
+    def record_llm_feedback_event(trace_id:,
+      rating:,
+      category: nil,
+      message: nil,
+      metadata: NewRelic::EMPTY_HASH)
+
+      record_api_supportability_metric(:record_llm_feedback_event)
+      unless NewRelic::Agent.config[:'distributed_tracing.enabled']
+        return NewRelic::Agent.logger.error('Distributed tracing must be enabled to record LLM feedback')
+      end
+
+      feedback_message_event = {
+        'trace_id': trace_id,
+        'rating': rating,
+        'category': category,
+        'message': message,
+        'id': NewRelic::Agent::GuidGenerator.generate_guid,
+        'ingest_source': NewRelic::Agent::Llm::LlmEvent::INGEST_SOURCE
+      }
+      feedback_message_event.merge!(metadata) unless metadata.empty?
+
+      NewRelic::Agent.record_custom_event(LLM_FEEDBACK_MESSAGE, feedback_message_event)
+    rescue ArgumentError
+      raise
+    rescue => exception
+      NewRelic::Agent.logger.error('record_llm_feedback_event', exception)
+    end
+
+    # @!endgroup
+
+    # @!group LLM callbacks
+
+    # Set a callback proc for calculating `token_count` attributes for
+    # LlmEmbedding and LlmChatCompletionMessage events
+    #
+    # @param callback_proc [Proc] the callback proc
+    #
+    # This method should be called only once to set a callback for
+    # use with all LLM token calculations. If it is called multiple times, each
+    # new callback will replace the old one.
+    #
+    # The proc will be called with a single hash as its input argument and
+    # must return an Integer representing the number of tokens used for that
+    # particular prompt, completion message, or embedding. Values less than or
+    # equal to 0 will not be attached to an event.
+    #
+    # The hash has the following keys:
+    #
+    # :model => [String] The name of the LLM model
+    # :content => [String] The message content or prompt
+    #
+    # @api public
+    #
+    def set_llm_token_count_callback(callback_proc)
+      unless callback_proc.is_a?(Proc)
+        NewRelic::Agent.logger.error("#{self}.#{__method__}: expected an argument of type Proc, " \
+                                     "got #{callback_proc.class}")
+        return
+      end
+
+      record_api_supportability_metric(:set_llm_token_count_callback)
+      @llm_token_count_callback = callback_proc
+    end
+
     # @!endgroup
 
     # @!group Manual agent configuration and startup/shutdown
@@ -618,16 +803,19 @@ module NewRelic
     def add_custom_attributes(params) # THREAD_LOCAL_ACCESS
       record_api_supportability_metric(:add_custom_attributes)
 
-      if params.is_a?(Hash)
-        Transaction.tl_current&.add_custom_attributes(params)
-
-        segment = ::NewRelic::Agent::Tracer.current_segment
-        if segment
-          add_new_segment_attributes(params, segment)
-        end
-      else
+      unless params.is_a?(Hash)
         ::NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_attributes. Expected Hash but got #{params.class}")
+        return
       end
+
+      if NewRelic::Agent.agent&.serverless?
+        ::NewRelic::Agent.logger.warn('Custom attributes are not supported in serverless mode')
+        return
+      end
+
+      Transaction.tl_current&.add_custom_attributes(params)
+      segment = ::NewRelic::Agent::Tracer.current_segment
+      add_new_segment_attributes(params, segment) if segment
     end
 
     def add_new_segment_attributes(params, segment)

data/lib/new_relic/constants.rb

@@ -11,6 +11,8 @@ module NewRelic
   EMPTY_HASH = {}.freeze
   EMPTY_STR = ''
 
+  LANGUAGE = 'ruby'
+
   HTTP = 'HTTP'
   HTTPS = 'HTTPS'
   UNKNOWN = 'Unknown'

data/lib/new_relic/control/frameworks/grape.rb

@@ -0,0 +1,14 @@
+# 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/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Grape
+      class Grape < NewRelic::Control::Frameworks::Ruby
+      end
+    end
+  end
+end

data/lib/new_relic/control/frameworks/padrino.rb

@@ -0,0 +1,14 @@
+# 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/control/frameworks/sinatra'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Padrino
+      class Padrino < NewRelic::Control::Frameworks::Sinatra
+      end
+    end
+  end
+end

data/lib/new_relic/control/frameworks/rails4.rb

@@ -9,9 +9,7 @@ module NewRelic
     module Frameworks
       class Rails4 < NewRelic::Control::Frameworks::Rails3
         def rails_gem_list
-          Bundler.rubygems.all_specs.map do |gem|
-            "#{gem.name} (#{gem.version})"
-          end
+          NewRelic::Helper.rubygems_specs.map { |gem| "#{gem.name} (#{gem.version})" }
         end
 
         def append_plugin_list

data/lib/new_relic/control/instance_methods.rb

@@ -73,9 +73,11 @@ module NewRelic
         init_config(options)
         NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
         init_instrumentation
+        init_security_agent
       end
 
       def determine_env(options)
+        options[:env] = :serverless if local_env.discovered_dispatcher == :serverless
         env = options[:env] || self.env
         env = env.to_s
 
@@ -95,6 +97,12 @@ module NewRelic
       def configure_agent(env, options)
         manual = Agent::Configuration::ManualSource.new(options)
         Agent.config.replace_or_add_config(manual)
+
+        # if manual config sees serverless mode enabled, then the proc
+        # must have returned 'true'. don't bother with YAML and high security
+        # in a serverless context
+        return if Agent.config[:'serverless_mode.enabled']
+
         yaml_source = Agent::Configuration::YamlSource.new(config_file_path, env)
         log_yaml_source_failures(yaml_source) if yaml_source.failed?
         Agent.config.replace_or_add_config(yaml_source)

data/lib/new_relic/control/private_instance_methods.rb

@@ -43,6 +43,10 @@ module NewRelic
           DependencyDetection.detect!
         end
       end
+
+      def init_security_agent
+        SecurityInterface.instance.init_agent
+      end
     end
   end
 end

data/lib/new_relic/control/security_interface.rb

@@ -0,0 +1,57 @@
+# 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 'singleton'
+
+module NewRelic
+  class Control
+    class SecurityInterface
+      include Singleton
+
+      attr_accessor :wait
+
+      SUPPORTABILITY_PREFIX_SECURITY = 'Supportability/Ruby/SecurityAgent/Enabled/'
+      SUPPORTABILITY_PREFIX_SECURITY_AGENT = 'Supportability/Ruby/SecurityAgent/Agent/Enabled/'
+      ENABLED = 'enabled'
+      DISABLED = 'disabled'
+
+      def agent_started?
+        (@agent_started ||= false) == true
+      end
+
+      def waiting?
+        (@wait ||= false) == true
+      end
+
+      def init_agent
+        return if agent_started? || waiting?
+
+        record_supportability_metrics
+
+        if Agent.config[:'security.agent.enabled'] && !Agent.config[:high_security]
+          Agent.logger.info('Invoking New Relic security module')
+          require 'newrelic_security'
+
+          @agent_started = true
+        else
+          Agent.logger.info('New Relic Security is completely disabled by one of the user-provided configurations: `security.agent.enabled` or `high_security`. Not loading security capabilities.')
+          Agent.logger.info("high_security = #{Agent.config[:high_security]}")
+          Agent.logger.info("security.agent.enabled = #{Agent.config[:'security.agent.enabled']}")
+        end
+      rescue LoadError
+        Agent.logger.info('New Relic security agent not found - skipping')
+      rescue StandardError => exception
+        Agent.logger.error("Exception in New Relic security module loading: #{exception} #{exception.backtrace}")
+      end
+
+      def record_supportability_metrics
+        Agent.config[:'security.agent.enabled'] ? security_agent_metric(ENABLED) : security_agent_metric(DISABLED)
+      end
+
+      def security_agent_metric(setting)
+        NewRelic::Agent.record_metric_once(SUPPORTABILITY_PREFIX_SECURITY_AGENT + setting)
+      end
+    end
+  end
+end

data/lib/new_relic/control.rb

@@ -8,7 +8,6 @@ require 'new_relic/local_environment'
 require 'new_relic/language_support'
 require 'new_relic/helper'
 
-require 'singleton'
 require 'erb'
 require 'socket'
 require 'net/https'
@@ -18,6 +17,7 @@ require 'new_relic/control/server_methods'
 require 'new_relic/control/instrumentation'
 require 'new_relic/control/class_methods'
 require 'new_relic/control/instance_methods'
+require 'new_relic/control/security_interface'
 
 require 'new_relic/agent'
 require 'new_relic/delayed_job_injection'