newrelic_rpm 9.7.0 → 9.16.1

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

@@ -16,10 +16,6 @@ DependencyDetection.defer do
   depends_on { Sinatra::Base.private_method_defined?(:process_route) }
   depends_on { Sinatra::Base.private_method_defined?(:route_eval) }
 
-  executes do
-    NewRelic::Agent.logger.info('Installing Sinatra instrumentation')
-  end
-
   executes do
     if use_prepend?
       prepend_instrument Sinatra::Base, NewRelic::Agent::Instrumentation::Sinatra::Prepend
@@ -32,27 +28,15 @@ DependencyDetection.defer do
   end
 
   executes do
+    supportability_name = NewRelic::Agent::Instrumentation::Sinatra::Tracer::INSTRUMENTATION_NAME
     # These requires are inside an executes block because they require rack, and
     # we can't be sure that rack is available when this file is first required.
     require 'new_relic/rack/agent_hooks'
     require 'new_relic/rack/browser_monitoring'
     if use_prepend?
-      prepend_instrument Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
+      prepend_instrument Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend, supportability_name
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain, supportability_name
     end
   end
-
-  executes do
-    next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
-
-    deprecation_msg = 'The Ruby agent is dropping support for Sinatra versions below 2.0.0 ' \
-      'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
-
-    NewRelic::Agent.logger.log_once(
-      :warn,
-      :deprecated_sinatra_version,
-      deprecation_msg
-    )
-  end
 end

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

@@ -10,6 +10,7 @@ module NewRelic
         EVENT_ATTRIBUTES = %i[http_status method num_retries path request_id].freeze
         ATTRIBUTE_NAMESPACE = 'stripe.user_data'
         ATTRIBUTE_FILTER_TYPES = %i[include exclude].freeze
+        PATH_PORTION_PATTERN = %r{^/([^/]+/[^/]+)(?:/|\z)}.freeze
 
         def start_segment(event)
           return unless is_execution_traced?
@@ -39,7 +40,27 @@ module NewRelic
         end
 
         def metric_name(event)
-          "Stripe#{event.path}/#{event.method}"
+          # Grab only the first 2 items from the slash (/) delimited event path.
+          # These items are the API version string and the category. Grabbing
+          # any more of the path will result in unique method names that will
+          # easily grow to be too numerous to sort through in the UI and
+          # possibly even violate default New Relic metric count thresholds.
+          # See newrelic/newrelic-ruby-agent#2654 and
+          # newrelic/newrelic-ruby-agent#2709 for more details.
+          #
+          # In Ruby v3.4 benchmarks, using regex to get at the first two path
+          # elements was seen as more performant than using String#split.
+          #
+          # Regex legend:
+          #
+          # ^ = starts with
+          # / = a literal '/'
+          # () = capture
+          # (?:) = don't capture
+          # [^/]+ = 1 or more characters that are not '/'
+          # /|\z = a literal '/' OR the end of the string
+          path_portion = event.path =~ PATH_PORTION_PATTERN ? Regexp.last_match(1) : NewRelic::UNKNOWN
+          "Stripe/#{path_portion}/#{event.method}"
         end
 
         def add_stripe_attributes(segment, event)

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

@@ -9,8 +9,6 @@ DependencyDetection.defer do
   named :thread
 
   executes do
-    NewRelic::Agent.logger.info('Installing Thread Instrumentation')
-
     if use_prepend?
       prepend_instrument Thread, NewRelic::Agent::Instrumentation::MonitoredThread::Prepend
     else

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

@@ -11,10 +11,6 @@ DependencyDetection.defer do
 
   depends_on { defined?(Tilt) }
 
-  executes do
-    NewRelic::Agent.logger.info('Installing Tilt instrumentation')
-  end
-
   executes do
     if use_prepend?
       prepend_instrument Tilt::Template, NewRelic::Agent::Instrumentation::Tilt::Prepend

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

@@ -18,7 +18,6 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing Typhoeus instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/typhoeus_wrappers'
   end

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

@@ -10,19 +10,26 @@ module NewRelic::Agent::Instrumentation
       NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
 
       begin
-        segment = NewRelic::Agent::Tracer.start_segment(
-          name: metric_name(self.class.identifier, self.class.name)
-        )
+        segment = NewRelic::Agent::Tracer.start_segment(name: metric_name)
         yield
       rescue => e
-        ::NewRelic::Agent.logger.debug('Error capturing ViewComponent segment', e)
+        NewRelic::Agent.notice_error(e)
+        raise
       ensure
         segment&.finish
       end
     end
 
-    def metric_name(identifier, component)
-      "View/#{metric_path(identifier)}/#{component}"
+    def metric_name
+      # ViewComponent determines a component's identifier differently depending on the version
+      # https://github.com/ViewComponent/view_component/pull/2153
+      component_identifier = defined?(self.class.source_location) ? self.class.source_location : self.class.identifier
+
+      "View/#{metric_path(component_identifier)}/#{self.class.name}"
+    rescue => e
+      NewRelic::Agent.logger.error('Error identifying View Component metric name', e)
+
+      'View/component'
     end
 
     def metric_path(identifier)

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

@@ -15,8 +15,6 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing ViewComponent instrumentation')
-
     if use_prepend?
       prepend_instrument ViewComponent::Base, NewRelic::Agent::Instrumentation::ViewComponent::Prepend
     else

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -164,9 +164,8 @@ module NewRelic
 
       def add_ssl_for_http(data)
         ssl_for_http = NewRelic::Agent.config[:'browser_monitoring.ssl_for_http']
-        unless ssl_for_http.nil?
-          data[SSL_FOR_HTTP_KEY] = ssl_for_http
-        end
+
+        data[SSL_FOR_HTTP_KEY] = ssl_for_http if ssl_for_http
       end
 
       def add_attributes(data, txn)

data/lib/new_relic/agent/llm/chat_completion_message.rb

@@ -0,0 +1,25 @@
+# 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 Llm
+      class ChatCompletionMessage < LlmEvent
+        ATTRIBUTES = %i[content role sequence completion_id token_count
+          is_response]
+        EVENT_NAME = 'LlmChatCompletionMessage'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/chat_completion_summary.rb

@@ -0,0 +1,66 @@
+# 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 'response_headers'
+
+module NewRelic
+  module Agent
+    module Llm
+      class ChatCompletionSummary < LlmEvent
+        include ResponseHeaders
+
+        ATTRIBUTES = %i[request_max_tokens response_number_of_messages
+          request_model response_choices_finish_reason request_temperature
+          duration error]
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          response_number_of_messages: 'response.number_of_messages',
+          request_model: 'request.model',
+          response_choices_finish_reason: 'response.choices.finish_reason',
+          request_temperature: 'request.temperature'
+        }
+        ERROR_COMPLETION_ID = 'completion_id'
+        EVENT_NAME = 'LlmChatCompletionSummary'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ResponseHeaders::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def attribute_name_exceptions
+          # TODO: OLD RUBIES < 2.6
+          # Hash#merge accepts multiple arguments in 2.6
+          # Remove condition once support for Ruby <2.6 is dropped
+          if RUBY_VERSION >= '2.6.0'
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
+          else
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)
+          end
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+
+        def error_attributes(exception)
+          attrs = {ERROR_COMPLETION_ID => id}
+
+          error_attributes_from_response(exception, attrs)
+        end
+
+        private
+
+        def error_attributes_from_response(exception, attrs)
+          return attrs unless exception.respond_to?(:response)
+
+          attrs[ERROR_ATTRIBUTE_STATUS_CODE] = exception.response.dig(:status)
+          attrs[ERROR_ATTRIBUTE_CODE] = exception.response.dig(:body, ERROR_STRING, CODE_STRING)
+          attrs[ERROR_ATTRIBUTE_PARAM] = exception.response.dig(:body, ERROR_STRING, PARAM_STRING)
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/embedding.rb

@@ -0,0 +1,60 @@
+# 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 Llm
+      class Embedding < LlmEvent
+        include ResponseHeaders
+
+        ATTRIBUTES = %i[input request_model token_count duration error].freeze
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          request_model: 'request.model'
+        }.freeze
+        ERROR_EMBEDDING_ID = 'embedding_id'
+        EVENT_NAME = 'LlmEmbedding'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ResponseHeaders::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def attribute_name_exceptions
+          # TODO: OLD RUBIES < 2.6
+          # Hash#merge accepts multiple arguments in 2.6
+          # Remove condition once support for Ruby <2.6 is dropped
+          if RUBY_VERSION >= '2.6.0'
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
+          else
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)
+          end
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+
+        def error_attributes(exception)
+          attrs = {}
+          attrs[ERROR_EMBEDDING_ID] = id
+
+          error_attributes_from_response(exception, attrs)
+        end
+
+        private
+
+        def error_attributes_from_response(exception, attrs)
+          return attrs unless exception.respond_to?(:response)
+
+          attrs[ERROR_ATTRIBUTE_STATUS_CODE] = exception.response.dig(:status)
+          attrs[ERROR_ATTRIBUTE_CODE] = exception.response.dig(:body, ERROR_STRING, CODE_STRING)
+          attrs[ERROR_ATTRIBUTE_PARAM] = exception.response.dig(:body, ERROR_STRING, PARAM_STRING)
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/llm_event.rb

@@ -0,0 +1,95 @@
+# 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 Llm
+      class LlmEvent
+        # Every subclass must define its own ATTRIBUTES constant, an array of symbols representing
+        # that class's unique attributes
+        ATTRIBUTES = %i[id request_id span_id trace_id response_model vendor
+          ingest_source metadata]
+        # These attributes should not be passed as arguments to initialize and will be set by the agent
+        AGENT_DEFINED_ATTRIBUTES = %i[span_id trace_id ingest_source]
+        # Some attributes have names that can't be written as symbols used for metaprogramming.
+        # The ATTRIBUTE_NAME_EXCEPTIONS hash should use the symbolized version of the name as the key
+        # and the string version expected by the UI as the value.
+        ATTRIBUTE_NAME_EXCEPTIONS = {response_model: 'response.model'}
+        INGEST_SOURCE = 'Ruby'
+        ERROR_ATTRIBUTE_STATUS_CODE = 'http.statusCode'
+        ERROR_ATTRIBUTE_CODE = 'error.code'
+        ERROR_ATTRIBUTE_PARAM = 'error.param'
+        ERROR_STRING = 'error'
+        CODE_STRING = 'code'
+        PARAM_STRING = 'param'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def self.set_llm_agent_attribute_on_transaction
+          NewRelic::Agent::Transaction.add_agent_attribute(:llm, true, NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
+        end
+
+        # This initialize method is used for all subclasses.
+        # It leverages the subclass's `attributes` method to iterate through
+        # all the attributes for that subclass.
+        # It assigns instance variables for all arguments passed to the method.
+        # It also assigns agent-defined attributes.
+        def initialize(opts = {})
+          (attributes - AGENT_DEFINED_ATTRIBUTES).each do |attr|
+            instance_variable_set(:"@#{attr}", opts[attr]) if opts.key?(attr)
+          end
+
+          @id = id || NewRelic::Agent::GuidGenerator.generate_guid
+          @span_id = NewRelic::Agent::Tracer.current_span_id
+          @trace_id = NewRelic::Agent::Tracer.current_trace_id
+          @ingest_source = INGEST_SOURCE
+        end
+
+        # All subclasses use event_attributes to get a full hash of all
+        # attributes and their values
+        def event_attributes
+          attributes_hash = attributes.each_with_object({}) do |attr, hash|
+            hash[replace_attr_with_string(attr)] = instance_variable_get(:"@#{attr}")
+          end
+          attributes_hash.merge!(metadata) && attributes_hash.delete(:metadata) if !metadata.nil?
+
+          attributes_hash
+        end
+
+        # Subclasses define an attributes method to concatenate attributes
+        # defined across their ancestors and other modules
+        def attributes
+          ATTRIBUTES
+        end
+
+        # Subclasses that record events will override this method
+        def event_name
+        end
+
+        # Some attribute names include periods, which aren't valid values for
+        # Ruby method names. This method returns a Hash with the key as the
+        # Ruby symbolized version of the attribute and the value as the
+        # period-delimited string expected upstream.
+        def attribute_name_exceptions
+          ATTRIBUTE_NAME_EXCEPTIONS
+        end
+
+        def record
+          NewRelic::Agent.record_custom_event(event_name, event_attributes)
+        end
+
+        # Subclasses that add attributes to noticed errors will override this method
+        def error_attributes(exception)
+          NewRelic::EMPTY_HASH
+        end
+
+        private
+
+        def replace_attr_with_string(attr)
+          attribute_name_exceptions.fetch(attr, attr)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/response_headers.rb

@@ -0,0 +1,80 @@
+# 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 Llm
+      module ResponseHeaders
+        ATTRIBUTES = %i[response_organization llm_version ratelimit_limit_requests
+          ratelimit_limit_tokens ratelimit_remaining_requests
+          ratelimit_remaining_tokens ratelimit_reset_requests
+          ratelimit_reset_tokens ratelimit_limit_tokens_usage_based
+          ratelimit_reset_tokens_usage_based
+          ratelimit_remaining_tokens_usage_based].freeze
+
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          response_organization: 'response.organization',
+          llm_version: 'response.headers.llmVersion',
+          ratelimit_limit_requests: 'response.headers.ratelimitLimitRequests',
+          ratelimit_limit_tokens: 'response.headers.ratelimitLimitTokens',
+          ratelimit_remaining_requests: 'response.headers.ratelimitRemainingRequests',
+          ratelimit_remaining_tokens: 'response.headers.ratelimitRemainingTokens',
+          ratelimit_reset_requests: 'response.headers.ratelimitResetRequests',
+          ratelimit_reset_tokens: 'response.headers.ratelimitResetTokens',
+          ratelimit_limit_tokens_usage_based: 'response.headers.ratelimitLimitTokensUsageBased',
+          ratelimit_reset_tokens_usage_based: 'response.headers.ratelimitResetTokensUsageBased',
+          ratelimit_remaining_tokens_usage_based: 'response.headers.ratelimitRemainingTokensUsageBased'
+        }.freeze
+
+        OPENAI_ORGANIZATION = 'openai-organization'
+        OPENAI_VERSION = 'openai-version'
+        X_RATELIMIT_LIMIT_REQUESTS = 'x-ratelimit-limit-requests'
+        X_RATELIMIT_LIMIT_TOKENS = 'x-ratelimit-limit-tokens'
+        X_RATELIMIT_REMAINING_REQUESTS = 'x-ratelimit-remaining-requests'
+        X_RATELIMIT_REMAINING_TOKENS = 'x-ratelimit-remaining-tokens'
+        X_RATELIMIT_RESET_REQUESTS = 'x-ratelimit-reset-requests'
+        X_RATELIMIT_RESET_TOKENS = 'x-ratelimit-reset-tokens'
+        X_RATELIMIT_LIMIT_TOKENS_USAGE_BASED = 'x-ratelimit-limit-tokens-usage-based'
+        X_RATELIMIT_RESET_TOKENS_USAGE_BASED = 'x-ratelimit-reset-tokens-usage-based'
+        X_RATELIMIT_REMAINING_TOKENS_USAGE_BASED = 'x-ratelimit-remaining-tokens-usage-based'
+        X_REQUEST_ID = 'x-request-id'
+
+        attr_accessor(*ATTRIBUTES)
+
+        # Headers is a hash of Net::HTTP response headers
+        def populate_openai_response_headers(headers)
+          # Embedding, ChatCompletionSummary, and ChatCompletionMessage all need
+          # request_id, so it's defined in LlmEvent. ChatCompletionMessage
+          # adds the attribute via ChatCompletionSummary.
+          self.request_id = headers[X_REQUEST_ID]&.first
+          self.response_organization = headers[OPENAI_ORGANIZATION]&.first
+          self.llm_version = headers[OPENAI_VERSION]&.first
+          self.ratelimit_limit_requests = headers[X_RATELIMIT_LIMIT_REQUESTS]&.first.to_i
+          self.ratelimit_limit_tokens = headers[X_RATELIMIT_LIMIT_TOKENS]&.first.to_i
+          remaining_headers(headers)
+          reset_headers(headers)
+          tokens_usage_based_headers(headers)
+        end
+
+        private
+
+        def remaining_headers(headers)
+          self.ratelimit_remaining_requests = headers[X_RATELIMIT_REMAINING_REQUESTS]&.first.to_i
+          self.ratelimit_remaining_tokens = headers[X_RATELIMIT_REMAINING_TOKENS]&.first.to_i
+        end
+
+        def reset_headers(headers)
+          self.ratelimit_reset_requests = headers[X_RATELIMIT_RESET_REQUESTS]&.first
+          self.ratelimit_reset_tokens = headers[X_RATELIMIT_RESET_TOKENS]&.first
+        end
+
+        def tokens_usage_based_headers(headers)
+          self.ratelimit_limit_tokens_usage_based = headers[X_RATELIMIT_LIMIT_TOKENS_USAGE_BASED]&.first.to_i
+          self.ratelimit_reset_tokens_usage_based = headers[X_RATELIMIT_RESET_TOKENS_USAGE_BASED]&.first
+          self.ratelimit_remaining_tokens_usage_based = headers[X_RATELIMIT_REMAINING_TOKENS_USAGE_BASED]&.first.to_i
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm.rb

@@ -0,0 +1,49 @@
+# 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 'llm/llm_event'
+require_relative 'llm/chat_completion_message'
+require_relative 'llm/chat_completion_summary'
+require_relative 'llm/embedding'
+require_relative 'llm/response_headers'
+
+module NewRelic
+  module Agent
+    class LLM
+      INPUT = 'input'
+      CONTENT = 'content'
+      SEGMENT_PATTERN = %r{Llm/.+/OpenAI/.+}.freeze
+
+      def self.instrumentation_enabled?
+        NewRelic::Agent.config[:'ai_monitoring.enabled']
+      end
+
+      # LLM content-related attributes are exempt from the 4095 byte limit
+      def self.exempt_event_attribute?(type, key)
+        return false unless instrumentation_enabled?
+
+        (type == NewRelic::Agent::Llm::Embedding::EVENT_NAME && key == INPUT) ||
+          (type == NewRelic::Agent::Llm::ChatCompletionMessage::EVENT_NAME && key == CONTENT)
+      end
+
+      def self.openai?
+        @openai ||= %i[prepend chain].include?(NewRelic::Agent.config[:'instrumentation.ruby_openai']) &&
+          NewRelic::Agent.config[:'ai_monitoring.enabled']
+      end
+
+      # Used in NetHTTP instrumentation
+      def self.openai_parent?(segment)
+        return false unless openai?
+
+        segment&.parent&.name&.match?(SEGMENT_PATTERN)
+      end
+
+      def self.populate_openai_response_headers(response, parent)
+        return unless parent.instance_variable_defined?(:@llm_event)
+
+        parent.llm_event.populate_openai_response_headers(response.to_hash)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/local_log_decorator.rb

@@ -12,6 +12,12 @@ module NewRelic
         return message unless decorating_enabled?
 
         metadata = NewRelic::Agent.linking_metadata
+
+        if message.is_a?(Hash)
+          message.merge!(metadata) unless message.frozen?
+          return
+        end
+
         formatted_metadata = " NR-LINKING|#{metadata[ENTITY_GUID_KEY]}|#{metadata[HOSTNAME_KEY]}|" \
                              "#{metadata[TRACE_ID_KEY]}|#{metadata[SPAN_ID_KEY]}|" \
                              "#{escape_entity_name(metadata[ENTITY_NAME_KEY])}|"
@@ -23,7 +29,8 @@ module NewRelic
 
       def decorating_enabled?
         NewRelic::Agent.config[:'application_logging.enabled'] &&
-          NewRelic::Agent::Instrumentation::Logger.enabled? &&
+          (NewRelic::Agent::Instrumentation::Logger.enabled? ||
+            NewRelic::Agent::Instrumentation::LogStasher.enabled?) &&
           NewRelic::Agent.config[:'application_logging.local_decorating.enabled']
       end