newrelic_rpm 9.2.0 → 9.5.0

data/lib/new_relic/agent/instrumentation/rake/instrumentation.rb

@@ -7,11 +7,15 @@ module NewRelic
     module Instrumentation
       module Rake
         module Tracer
+          INSTRUMENTATION_NAME = 'Rake'
+
           def invoke_with_newrelic_tracing(*args)
             unless NewRelic::Agent::Instrumentation::Rake.should_trace?(name)
               return yield
             end
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               timeout = NewRelic::Agent.config[:'rake.connect_timeout']
               NewRelic::Agent.instance.wait_on_connect(timeout)

data/lib/new_relic/agent/instrumentation/redis/instrumentation.rb

@@ -6,6 +6,8 @@ require_relative 'constants'
 
 module NewRelic::Agent::Instrumentation
   module Redis
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def connect_with_tracing
       with_tracing(Constants::CONNECT, database: db) { yield }
     end
@@ -43,6 +45,8 @@ module NewRelic::Agent::Instrumentation
     private
 
     def with_tracing(operation, statement: nil, database: nil)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: Constants::PRODUCT_NAME,
         operation: operation,

data/lib/new_relic/agent/instrumentation/resque/instrumentation.rb

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation
   module Resque
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def with_tracing
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
         perform_action_with_newrelic_trace(
           :name => 'perform',

data/lib/new_relic/agent/instrumentation/roda/chain.rb

@@ -0,0 +1,43 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Chain
+      def self.instrument!
+        ::Roda.class_eval do
+          include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+          alias_method(:_roda_handle_main_route_without_tracing, :_roda_handle_main_route)
+
+          def _roda_handle_main_route(*args)
+            _roda_handle_main_route_with_tracing(*args) do
+              _roda_handle_main_route_without_tracing(*args)
+            end
+          end
+        end
+      end
+    end
+
+    module Build
+      module Chain
+        def self.instrument!
+          ::Roda.class_eval do
+            include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+            class << self
+              alias_method(:build_rack_app_without_tracing, :build_rack_app)
+
+              def build_rack_app
+                build_rack_app_with_tracing do
+                  build_rack_app_without_tracing
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/instrumentation.rb

@@ -0,0 +1,56 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Tracer
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      INSTRUMENTATION_NAME = 'Roda'
+
+      def self.included(clazz)
+        clazz.extend(self)
+      end
+
+      def newrelic_middlewares
+        middlewares = [NewRelic::Rack::BrowserMonitoring]
+        if NewRelic::Rack::AgentHooks.needed?
+          middlewares << NewRelic::Rack::AgentHooks
+        end
+        middlewares
+      end
+
+      def build_rack_app_with_tracing
+        unless NewRelic::Agent.config[:disable_roda_auto_middleware]
+          newrelic_middlewares.each do |middleware_class|
+            self.use middleware_class
+          end
+        end
+        yield
+      end
+
+      # Roda makes use of Rack, so we can get params from the request object
+      def rack_request_params
+        begin
+          @_request.params
+        rescue => e
+          NewRelic::Agent.logger.debug('Failed to get params from Rack request.', e)
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def _roda_handle_main_route_with_tracing(*args)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        perform_action_with_newrelic_trace(
+          category: :roda,
+          name: ::NewRelic::Agent::Instrumentation::Roda::TransactionNamer.transaction_name(request),
+          params: ::NewRelic::Agent::ParameterFiltering::apply_filters(request.env, rack_request_params)
+        ) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/prepend.rb

@@ -0,0 +1,24 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+
+      def _roda_handle_main_route(*args)
+        _roda_handle_main_route_with_tracing(*args) { super }
+      end
+    end
+
+    module Build
+      module Prepend
+        include ::NewRelic::Agent::Instrumentation::Roda::Tracer
+        def build_rack_app
+          build_rack_app_with_tracing { super }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb

@@ -0,0 +1,30 @@
+# 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 Instrumentation
+      module Roda
+        module TransactionNamer
+          extend self
+
+          ROOT = '/'.freeze
+          REGEX_MULTIPLE_SLASHES = %r{^[/^]*(.*?)[/$?]*$}.freeze
+
+          def transaction_name(request)
+            path = request.path || ::NewRelic::Agent::UNKNOWN_METRIC
+            name = path.gsub(REGEX_MULTIPLE_SLASHES, '\1') # remove any rogue slashes
+            name = ROOT if name.empty?
+            name = "#{request.request_method} #{name}" if request.respond_to?(:request_method)
+
+            name
+          rescue => e
+            ::NewRelic::Agent.logger.debug("#{e.class} : #{e.message} - Error encountered trying to identify Roda transaction name")
+            ::NewRelic::Agent::UNKNOWN_METRIC
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda.rb

@@ -0,0 +1,34 @@
+# 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 'roda/instrumentation'
+require_relative 'roda/roda_transaction_namer'
+
+DependencyDetection.defer do
+  named :roda
+
+  depends_on do
+    defined?(Roda) &&
+      Gem::Version.new(Roda::RodaVersion) >= Gem::Version.new('3.19.0') &&
+      Roda::RodaPlugins::Base::ClassMethods.private_method_defined?(:build_rack_app) &&
+      Roda::RodaPlugins::Base::InstanceMethods.method_defined?(:_roda_handle_main_route)
+  end
+
+  executes do
+    require_relative '../../rack/agent_hooks'
+    require_relative '../../rack/browser_monitoring'
+
+    NewRelic::Agent.logger.info('Installing Roda instrumentation')
+
+    if use_prepend?
+      require_relative 'roda/prepend'
+      prepend_instrument Roda.singleton_class, NewRelic::Agent::Instrumentation::Roda::Build::Prepend
+      prepend_instrument Roda, NewRelic::Agent::Instrumentation::Roda::Prepend
+    else
+      require_relative 'roda/chain'
+      chain_instrument NewRelic::Agent::Instrumentation::Roda::Build::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::Roda::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/sequel.rb

@@ -30,7 +30,7 @@ DependencyDetection.defer do
       else
         NewRelic::Agent.logger.info('Detected Sequel version %s.' % [Sequel::VERSION])
         NewRelic::Agent.logger.info('Please see additional documentation: ' +
-          'https://newrelic.com/docs/ruby/sequel-instrumentation')
+          'https://docs.newrelic.com/docs/apm/agents/ruby-agent/frameworks/sequel-instrumentation/')
       end
 
       Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|

data/lib/new_relic/agent/instrumentation/sidekiq/client.rb

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation::Sidekiq
   class Client
     include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
 
+    INSTRUMENTATION_NAME = 'SidekiqClient'
+
     def call(_worker_class, job, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
       yield
     end

data/lib/new_relic/agent/instrumentation/sidekiq/server.rb

@@ -7,9 +7,16 @@ module NewRelic::Agent::Instrumentation::Sidekiq
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
     include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
 
+    ATTRIBUTE_BASE_NAMESPACE = 'sidekiq.args'
+    ATTRIBUTE_FILTER_TYPES = %i[include exclude].freeze
+    ATTRIBUTE_JOB_NAMESPACE = :"job.#{ATTRIBUTE_BASE_NAMESPACE}"
+    INSTRUMENTATION_NAME = 'SidekiqServer'
+
     # Client middleware has additional parameters, and our tests use the
     # middleware client-side to work inline.
     def call(worker, msg, queue, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       trace_args = if worker.respond_to?(:newrelic_trace_args)
         worker.newrelic_trace_args(msg, queue)
       else
@@ -18,10 +25,16 @@ module NewRelic::Agent::Instrumentation::Sidekiq
       trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
 
       perform_action_with_newrelic_trace(trace_args) do
-        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
-          NewRelic::Agent::AttributeFilter::DST_NONE)
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
+          NewRelic::Agent::AttributePreFiltering.pre_filter(msg['args'], self.class.nr_attribute_options),
+          ATTRIBUTE_JOB_NAMESPACE,
+          NewRelic::Agent::AttributeFilter::DST_NONE
+        )
+
+        if ::NewRelic::Agent.config[:'distributed_tracing.enabled'] && trace_headers&.any?
+          ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, 'Other')
+        end
 
-        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, 'Other') if ::NewRelic::Agent.config[:'distributed_tracing.enabled'] && trace_headers&.any?
         yield
       end
     end
@@ -33,5 +46,15 @@ module NewRelic::Agent::Instrumentation::Sidekiq
         :category => 'OtherTransaction/SidekiqJob'
       }
     end
+
+    def self.nr_attribute_options
+      @nr_attribute_options ||= begin
+        ATTRIBUTE_FILTER_TYPES.each_with_object({}) do |type, opts|
+          pattern =
+            NewRelic::Agent::AttributePreFiltering.formulate_regexp_union(:"#{ATTRIBUTE_BASE_NAMESPACE}.#{type}")
+          opts[type] = pattern if pattern
+        end.merge(attribute_namespace: ATTRIBUTE_JOB_NAMESPACE)
+      end
+    end
   end
 end

data/lib/new_relic/agent/instrumentation/sidekiq.rb

@@ -43,8 +43,8 @@ DependencyDetection.defer do
   executes do
     next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
 
-    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated.' \
-      'They will stop being monitored in version 9.0.0. ' \
+    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated ' \
+      'and will be dropped entirely in a future major New Relic Ruby agent release.' \
       'Please upgrade your Sidekiq version to continue receiving full support. '
 
     NewRelic::Agent.logger.log_once(

data/lib/new_relic/agent/instrumentation/sinatra/instrumentation.rb

@@ -13,6 +13,8 @@ module NewRelic::Agent::Instrumentation
     module Tracer
       include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+      INSTRUMENTATION_NAME = 'Sinatra'
+
       def self.included(clazz)
         clazz.extend(self)
       end
@@ -90,6 +92,8 @@ module NewRelic::Agent::Instrumentation
       end
 
       def dispatch_with_tracing
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         request_params = get_request_params
         filtered_params = ::NewRelic::Agent::ParameterFiltering::apply_filters(request.env, request_params || {})
 

data/lib/new_relic/agent/instrumentation/stripe.rb

@@ -0,0 +1,28 @@
+# 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/instrumentation/stripe_subscriber'
+
+DependencyDetection.defer do
+  named :stripe
+
+  depends_on do
+    NewRelic::Agent.config[:'instrumentation.stripe'] == 'enabled'
+  end
+
+  depends_on do
+    defined?(Stripe) &&
+      Gem::Version.new(Stripe::VERSION) >= Gem::Version.new('5.38.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing Stripe instrumentation')
+  end
+
+  executes do
+    newrelic_subscriber = NewRelic::Agent::Instrumentation::StripeSubscriber.new
+    Stripe::Instrumentation.subscribe(:request_begin) { |event| newrelic_subscriber.start_segment(event) }
+    Stripe::Instrumentation.subscribe(:request_end) { |event| newrelic_subscriber.finish_segment(event) }
+  end
+end

data/lib/new_relic/agent/instrumentation/stripe_subscriber.rb

@@ -0,0 +1,77 @@
+# 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 Instrumentation
+      class StripeSubscriber
+        DEFAULT_DESTINATIONS = AttributeFilter::DST_SPAN_EVENTS
+        EVENT_ATTRIBUTES = %i[http_status method num_retries path request_id].freeze
+        ATTRIBUTE_NAMESPACE = 'stripe.user_data'
+        ATTRIBUTE_FILTER_TYPES = %i[include exclude].freeze
+
+        def start_segment(event)
+          return unless is_execution_traced?
+
+          segment = NewRelic::Agent::Tracer.start_segment(name: metric_name(event))
+          event.user_data[:newrelic_segment] = segment
+        rescue => e
+          NewRelic::Agent.logger.error("Error starting New Relic Stripe segment: #{e}")
+        end
+
+        def finish_segment(event)
+          return unless is_execution_traced?
+
+          segment = remove_and_return_nr_segment(event)
+          add_stripe_attributes(segment, event)
+          add_custom_attributes(segment, event)
+        rescue => e
+          NewRelic::Agent.logger.error("Error finishing New Relic Stripe segment: #{e}")
+        ensure
+          segment&.finish
+        end
+
+        private
+
+        def is_execution_traced?
+          NewRelic::Agent::Tracer.state.is_execution_traced?
+        end
+
+        def metric_name(event)
+          "Stripe#{event.path}/#{event.method}"
+        end
+
+        def add_stripe_attributes(segment, event)
+          EVENT_ATTRIBUTES.each do |attribute|
+            segment.add_agent_attribute("stripe_#{attribute}", event.send(attribute), DEFAULT_DESTINATIONS)
+          end
+        end
+
+        def add_custom_attributes(segment, event)
+          return if NewRelic::Agent.config[:'stripe.user_data.include'].empty?
+
+          filtered_attributes = NewRelic::Agent::AttributePreFiltering.pre_filter_hash(event.user_data, nr_attribute_options)
+          filtered_attributes.each do |key, value|
+            segment.add_agent_attribute("stripe_user_data_#{key}", value, DEFAULT_DESTINATIONS)
+          end
+        end
+
+        def nr_attribute_options
+          ATTRIBUTE_FILTER_TYPES.each_with_object({}) do |type, opts|
+            pattern =
+              NewRelic::Agent::AttributePreFiltering.formulate_regexp_union(:"#{ATTRIBUTE_NAMESPACE}.#{type}")
+            opts[type] = pattern if pattern
+          end
+        end
+
+        def remove_and_return_nr_segment(event)
+          segment = event.user_data[:newrelic_segment]
+          event.user_data.delete(:newrelic_segment)
+
+          segment
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/thread/chain.rb

@@ -14,7 +14,7 @@ module NewRelic::Agent::Instrumentation
           alias_method(:initialize_without_new_relic, :initialize)
 
           def initialize(*args, &block)
-            traced_block = add_thread_tracing(*args, &block)
+            traced_block = add_thread_tracing(&block)
             initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
           end
         end

data/lib/new_relic/agent/instrumentation/thread/instrumentation.rb

@@ -17,7 +17,6 @@ module NewRelic
           return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
           NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-            *args,
             segment_name: 'Ruby/Thread',
             &block
           )

data/lib/new_relic/agent/instrumentation/thread/prepend.rb

@@ -12,7 +12,7 @@ module NewRelic
           include NewRelic::Agent::Instrumentation::MonitoredThread
 
           def initialize(*args, &block)
-            traced_block = add_thread_tracing(*args, &block)
+            traced_block = add_thread_tracing(&block)
             initialize_with_newrelic_tracing { super(*args, &traced_block) }
           end
         end

data/lib/new_relic/agent/instrumentation/tilt/instrumentation.rb

@@ -6,6 +6,8 @@ module NewRelic
   module Agent
     module Instrumentation
       module Tilt
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         def metric_name(klass, file)
           "View/#{klass}/#{file}/Rendering"
         end
@@ -21,6 +23,8 @@ module NewRelic
         end
 
         def render_with_tracing(*args, &block)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           begin
             finishable = Tracer.start_segment(
               name: metric_name(self.class, create_filename_for_metric(self.file))

data/lib/new_relic/agent/instrumentation/typhoeus/instrumentation.rb

@@ -8,8 +8,8 @@ module NewRelic
       module Typhoeus
         HYDRA_SEGMENT_NAME = 'External/Multiple/Typhoeus::Hydra/run'
         NOTICEABLE_ERROR_CLASS = 'Typhoeus::Errors::TyphoeusError'
-
         EARLIEST_VERSION = Gem::Version.new('0.5.3')
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def self.is_supported_version?
           Gem::Version.new(::Typhoeus::VERSION) >= EARLIEST_VERSION
@@ -31,6 +31,8 @@ module NewRelic
         end
 
         def with_tracing
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           segment = NewRelic::Agent::Tracer.start_segment(name: HYDRA_SEGMENT_NAME)
           instance_variable_set(:@__newrelic_hydra_segment, segment)
           begin
@@ -41,6 +43,8 @@ module NewRelic
         end
 
         def self.trace(request)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
 

data/lib/new_relic/agent/log_event_aggregator.rb

@@ -4,6 +4,7 @@
 
 require 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/log_priority'
+require 'new_relic/agent/log_event_attributes'
 
 module NewRelic
   module Agent
@@ -36,6 +37,10 @@ module NewRelic
       METRICS_ENABLED_KEY = :'application_logging.metrics.enabled'
       FORWARDING_ENABLED_KEY = :'application_logging.forwarding.enabled'
       DECORATING_ENABLED_KEY = :'application_logging.local_decorating.enabled'
+      LOG_LEVEL_KEY = :'application_logging.forwarding.log_level'
+      CUSTOM_ATTRIBUTES_KEY = :'application_logging.forwarding.custom_attributes'
+
+      attr_reader :attributes
 
       def initialize(events)
         super(events)
@@ -44,6 +49,7 @@ module NewRelic
         @seen_by_severity = Hash.new(0)
         @high_security = NewRelic::Agent.config[:high_security]
         @instrumentation_logger_enabled = NewRelic::Agent::Instrumentation::Logger.enabled?
+        @attributes = NewRelic::Agent::LogEventAttributes.new
         register_for_done_configuring(events)
       end
 
@@ -63,8 +69,9 @@ module NewRelic
           end
         end
 
+        return if severity_too_low?(severity)
         return if formatted_message.nil? || formatted_message.empty?
-        return unless NewRelic::Agent.config[:'application_logging.forwarding.enabled']
+        return unless NewRelic::Agent.config[FORWARDING_ENABLED_KEY]
         return if @high_security
 
         txn = NewRelic::Agent::Transaction.tl_current
@@ -114,6 +121,10 @@ module NewRelic
         ]
       end
 
+      def add_custom_attributes(custom_attributes)
+        attributes.add_custom_attributes(custom_attributes)
+      end
+
       # Because our transmission format (MELT) is different than historical
       # agent payloads, extract the munging here to keep the service focused
       # on the general harvest + transmit instead of the format.
@@ -130,6 +141,8 @@ module NewRelic
         # sent by classic logs-in-context
         common_attributes.delete(ENTITY_TYPE_KEY)
 
+        common_attributes.merge!(NewRelic::Agent.agent.log_event_aggregator.attributes.custom_attributes)
+
         _, items = data
         payload = [{
           common: {attributes: common_attributes},
@@ -149,6 +162,7 @@ module NewRelic
           @seen = 0
           @seen_by_severity.clear
         end
+
         super
       end
 
@@ -168,6 +182,8 @@ module NewRelic
           record_configuration_metric(METRICS_SUPPORTABILITY_FORMAT, METRICS_ENABLED_KEY)
           record_configuration_metric(FORWARDING_SUPPORTABILITY_FORMAT, FORWARDING_ENABLED_KEY)
           record_configuration_metric(DECORATING_SUPPORTABILITY_FORMAT, DECORATING_ENABLED_KEY)
+
+          add_custom_attributes(NewRelic::Agent.config[CUSTOM_ATTRIBUTES_KEY])
         end
       end
 
@@ -191,7 +207,7 @@ module NewRelic
       # these until harvest before recording them
       def record_customer_metrics
         return unless enabled?
-        return unless NewRelic::Agent.config[:'application_logging.metrics.enabled']
+        return unless NewRelic::Agent.config[METRICS_ENABLED_KEY]
 
         @counter_lock.synchronize do
           return unless @seen > 0
@@ -230,6 +246,37 @@ module NewRelic
 
         message.byteslice(0...MAX_BYTES)
       end
+
+      def minimum_log_level
+        if Logger::Severity.constants.include?(configured_log_level_constant)
+          configured_log_level_constant
+        else
+          NewRelic::Agent.logger.log_once(
+            :error,
+            'Invalid application_logging.forwarding.log_level ' \
+            "'#{NewRelic::Agent.config[LOG_LEVEL_KEY]}' specified! " \
+            "Must be one of #{Logger::Severity.constants.join('|')}. " \
+            "Using default level of 'debug'"
+          )
+          :DEBUG
+        end
+      end
+
+      def configured_log_level_constant
+        format_log_level_constant(NewRelic::Agent.config[LOG_LEVEL_KEY])
+      end
+
+      def format_log_level_constant(log_level)
+        log_level.upcase.to_sym
+      end
+
+      def severity_too_low?(severity)
+        severity_constant = format_log_level_constant(severity)
+        # always record custom log levels
+        return false unless Logger::Severity.constants.include?(severity_constant)
+
+        Logger::Severity.const_get(severity_constant) < Logger::Severity.const_get(minimum_log_level)
+      end
     end
   end
 end