newrelic_rpm 9.9.0 → 9.21.0

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/instrumentation.rb

@@ -8,11 +8,11 @@ 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')
+        EARLIEST_VERSION = '0.5.3'
         INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def self.is_supported_version?
-          Gem::Version.new(::Typhoeus::VERSION) >= EARLIEST_VERSION
+          NewRelic::Helper.version_satisfied?(::Typhoeus::VERSION, '>=', EARLIEST_VERSION)
         end
 
         def self.request_is_hydra_enabled?(request)

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,9 +10,7 @@ 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.notice_error(e)
@@ -22,8 +20,16 @@ module NewRelic::Agent::Instrumentation
       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_summary.rb

@@ -32,7 +32,7 @@ module NewRelic
           # 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'
+          if NewRelic::Helper.version_satisfied?(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)

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

@@ -25,7 +25,7 @@ module NewRelic
           # 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'
+          if NewRelic::Helper.version_satisfied?(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)

data/lib/new_relic/agent/local_log_decorator.rb

@@ -9,9 +9,15 @@ module NewRelic
       extend self
 
       def decorate(message)
-        return message unless decorating_enabled?
+        return message if !decorating_enabled? || message.nil?
 
         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,14 +29,25 @@ 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
 
       def escape_entity_name(entity_name)
         return unless entity_name
 
-        URI::DEFAULT_PARSER.escape(entity_name)
+        # TODO: OLD RUBIES 3.3
+        # URI version 1.0 marked URI::RFC3986_PARSER.escape as obsolete,
+        # which URI::DEFAULT_PARSER is an alias for.
+        # URI version 1.0+ will ship with Ruby 3.4
+        # Once we drop support for Rubies below 3.4, we can use the
+        # URI::RFC2396 parser exclusively.
+        if NewRelic::Helper.version_satisfied?(URI::VERSION, '>=', '1.0')
+          URI::RFC2396_PARSER.escape(entity_name)
+        else
+          URI::DEFAULT_PARSER.escape(entity_name)
+        end
       end
     end
   end

data/lib/new_relic/agent/log_event_aggregator.rb

@@ -20,10 +20,12 @@ module NewRelic
       DROPPED_METRIC = 'Logging/Forwarding/Dropped'.freeze
       SEEN_METRIC = 'Supportability/Logging/Forwarding/Seen'.freeze
       SENT_METRIC = 'Supportability/Logging/Forwarding/Sent'.freeze
-      OVERALL_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Ruby/Logger/%s'.freeze
+      LOGGER_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Ruby/Logger/%s'.freeze
+      LOGSTASHER_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Ruby/LogStasher/%s'.freeze
       METRICS_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Metrics/Ruby/%s'.freeze
       FORWARDING_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Forwarding/Ruby/%s'.freeze
       DECORATING_SUPPORTABILITY_FORMAT = 'Supportability/Logging/LocalDecorating/Ruby/%s'.freeze
+      LABELS_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Labels/Ruby/%s'.freeze
       MAX_BYTES = 32768 # 32 * 1024 bytes (32 kibibytes)
 
       named :LogEventAggregator
@@ -37,6 +39,7 @@ module NewRelic
       METRICS_ENABLED_KEY = :'application_logging.metrics.enabled'
       FORWARDING_ENABLED_KEY = :'application_logging.forwarding.enabled'
       DECORATING_ENABLED_KEY = :'application_logging.local_decorating.enabled'
+      LABELS_ENABLED_KEY = :'application_logging.forwarding.labels.enabled'
       LOG_LEVEL_KEY = :'application_logging.forwarding.log_level'
       CUSTOM_ATTRIBUTES_KEY = :'application_logging.forwarding.custom_attributes'
 
@@ -50,6 +53,7 @@ module NewRelic
         @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
 
@@ -58,38 +62,71 @@ module NewRelic
       end
 
       def record(formatted_message, severity)
-        return unless enabled?
+        return unless logger_enabled?
 
         severity = 'UNKNOWN' if severity.nil? || severity.empty?
+        increment_event_counters(severity)
+
+        return if formatted_message.nil? || formatted_message.empty?
+        return unless monitoring_conditions_met?(severity)
+
+        txn = NewRelic::Agent::Transaction.tl_current
+        priority = LogPriority.priority_for(txn)
+
+        return txn.add_log_event(create_event(priority, formatted_message, severity)) if txn
 
-        if NewRelic::Agent.config[METRICS_ENABLED_KEY]
-          @counter_lock.synchronize do
-            @seen += 1
-            @seen_by_severity[severity] += 1
+        @lock.synchronize do
+          @buffer.append(priority: priority) do
+            create_event(priority, formatted_message, severity)
           end
         end
+      rescue
+        nil
+      end
 
-        return if severity_too_low?(severity)
-        return if formatted_message.nil? || formatted_message.empty?
-        return unless NewRelic::Agent.config[FORWARDING_ENABLED_KEY]
-        return if @high_security
+      def record_logstasher_event(log)
+        return unless logstasher_enabled?
+
+        # LogStasher logs do not inherently include a message key, so most logs are recorded.
+        # But when the key exists, we should not record the log if the message value is nil or empty.
+        return if log.key?('message') && (log['message'].nil? || log['message'].empty?)
+
+        severity = determine_severity(log)
+        increment_event_counters(severity)
+
+        return unless monitoring_conditions_met?(severity)
 
         txn = NewRelic::Agent::Transaction.tl_current
         priority = LogPriority.priority_for(txn)
 
-        if txn
-          return txn.add_log_event(create_event(priority, formatted_message, severity))
-        else
-          return @lock.synchronize do
-            @buffer.append(priority: priority) do
-              create_event(priority, formatted_message, severity)
-            end
+        return txn.add_log_event(create_logstasher_event(priority, severity, log)) if txn
+
+        @lock.synchronize do
+          @buffer.append(priority: priority) do
+            create_logstasher_event(priority, severity, log)
           end
         end
       rescue
         nil
       end
 
+      def monitoring_conditions_met?(severity)
+        !severity_too_low?(severity) && NewRelic::Agent.config[FORWARDING_ENABLED_KEY] && !@high_security
+      end
+
+      def determine_severity(log)
+        log['level'] ? log['level'].to_s.upcase : 'UNKNOWN'
+      end
+
+      def increment_event_counters(severity)
+        return unless NewRelic::Agent.config[METRICS_ENABLED_KEY]
+
+        @counter_lock.synchronize do
+          @seen += 1
+          @seen_by_severity[severity] += 1
+        end
+      end
+
       def record_batch(txn, logs)
         # Ensure we have the same shared priority
         priority = LogPriority.priority_for(txn)
@@ -104,15 +141,17 @@ module NewRelic
         end
       end
 
-      def create_event(priority, formatted_message, severity)
-        formatted_message = truncate_message(formatted_message)
-
-        event = LinkingMetadata.append_trace_linking_metadata({
+      def add_event_metadata(formatted_message, severity)
+        metadata = {
           LEVEL_KEY => severity,
-          MESSAGE_KEY => formatted_message,
           TIMESTAMP_KEY => Process.clock_gettime(Process::CLOCK_REALTIME) * 1000
-        })
+        }
+        metadata[MESSAGE_KEY] = formatted_message unless formatted_message.nil?
+
+        LinkingMetadata.append_trace_linking_metadata(metadata)
+      end
 
+      def create_prioritized_event(priority, event)
         [
           {
             PrioritySampledBuffer::PRIORITY_KEY => priority
@@ -121,10 +160,39 @@ module NewRelic
         ]
       end
 
+      def create_event(priority, formatted_message, severity)
+        formatted_message = truncate_message(formatted_message)
+        event = add_event_metadata(formatted_message, severity)
+
+        create_prioritized_event(priority, event)
+      end
+
+      def create_logstasher_event(priority, severity, log)
+        formatted_message = log['message'] ? truncate_message(log['message']) : nil
+        event = add_event_metadata(formatted_message, severity)
+        add_logstasher_event_attributes(event, log)
+
+        create_prioritized_event(priority, event)
+      end
+
+      def add_logstasher_event_attributes(event, log)
+        log_copy = log.dup
+        # Delete previously reported attributes
+        log_copy.delete('message')
+        log_copy.delete('level')
+        log_copy.delete('@timestamp')
+
+        event['attributes'] = log_copy
+      end
+
       def add_custom_attributes(custom_attributes)
         attributes.add_custom_attributes(custom_attributes)
       end
 
+      def labels
+        @labels ||= create_labels
+      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.
@@ -140,8 +208,9 @@ module NewRelic
         # To save on unnecessary data transmission, trim the entity.type
         # sent by classic logs-in-context
         common_attributes.delete(ENTITY_TYPE_KEY)
-
-        common_attributes.merge!(NewRelic::Agent.agent.log_event_aggregator.attributes.custom_attributes)
+        aggregator = NewRelic::Agent.agent.log_event_aggregator
+        common_attributes.merge!(aggregator.attributes.custom_attributes)
+        common_attributes.merge!(aggregator.labels)
 
         _, items = data
         payload = [{
@@ -166,10 +235,14 @@ module NewRelic
         super
       end
 
-      def enabled?
+      def logger_enabled?
         @enabled && @instrumentation_logger_enabled
       end
 
+      def logstasher_enabled?
+        @enabled && NewRelic::Agent::Instrumentation::LogStasher.enabled?
+      end
+
       private
 
       # We record once-per-connect metrics for enabled/disabled state at the
@@ -177,11 +250,12 @@ module NewRelic
       def register_for_done_configuring(events)
         events.subscribe(:server_source_configuration_added) do
           @high_security = NewRelic::Agent.config[:high_security]
-
-          record_configuration_metric(OVERALL_SUPPORTABILITY_FORMAT, OVERALL_ENABLED_KEY)
+          record_configuration_metric(LOGGER_SUPPORTABILITY_FORMAT, OVERALL_ENABLED_KEY)
+          record_configuration_metric(LOGSTASHER_SUPPORTABILITY_FORMAT, OVERALL_ENABLED_KEY)
           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)
+          record_configuration_metric(LABELS_SUPPORTABILITY_FORMAT, LABELS_ENABLED_KEY)
 
           add_custom_attributes(NewRelic::Agent.config[CUSTOM_ATTRIBUTES_KEY])
         end
@@ -262,6 +336,23 @@ module NewRelic
 
         Logger::Severity.const_get(severity_constant) < Logger::Severity.const_get(configured_log_level_constant)
       end
+
+      def create_labels
+        return NewRelic::EMPTY_HASH unless NewRelic::Agent.config[LABELS_ENABLED_KEY]
+
+        downcased_exclusions = NewRelic::Agent.config[:'application_logging.forwarding.labels.exclude'].map(&:downcase)
+        log_labels = {}
+
+        NewRelic::Agent.config.parsed_labels.each do |parsed_label|
+          next if downcased_exclusions.include?(parsed_label['label_type'].downcase)
+
+          # labels are referred to as tags in the UI, so prefix the
+          # label-related attributes with 'tags.*'
+          log_labels["tags.#{parsed_label['label_type']}"] = parsed_label['label_value']
+        end
+
+        log_labels
+      end
     end
   end
 end

data/lib/new_relic/agent/logging.rb

@@ -165,7 +165,7 @@ module NewRelic
         # Positional and Keyword arguments are separated beginning with Ruby 2.7
         # Signature of ::Logger constructor changes in Ruby 2.4 to have both positional and keyword args
         # We pivot on Ruby 2.7 for widest supportability with least amount of hassle.
-        if RUBY_VERSION < '2.7.0'
+        if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '2.7.0')
           def initialize(*args)
             super(*args)
             self.formatter = DecoratingFormatter.new

data/lib/new_relic/agent/messaging.rb

@@ -49,6 +49,7 @@ module NewRelic
       #
       # @return [NewRelic::Agent::Transaction::MessageBrokerSegment]
       #
+      # @!scope class
       # @api public
       #
       def start_message_broker_segment(action: nil,
@@ -107,6 +108,7 @@ module NewRelic
       # @return return value of given block, which will be the same as the
       #   return value of an un-instrumented subscribed callback
       #
+      # @!scope class
       # @api public
       #
       def wrap_message_broker_consume_transaction(library:,
@@ -117,7 +119,8 @@ module NewRelic
         queue_name: nil,
         exchange_type: nil,
         reply_to: nil,
-        correlation_id: nil)
+        correlation_id: nil,
+        action: nil)
 
         state = Tracer.state
         return yield if state.current_transaction
@@ -125,12 +128,12 @@ module NewRelic
         txn = nil
 
         begin
-          txn_name = transaction_name(library, destination_type, destination_name)
+          txn_name = transaction_name(library, destination_type, destination_name, action)
 
           txn = Tracer.start_transaction(name: txn_name, category: :message)
-
           if headers
-            txn.distributed_tracer.consume_message_headers(headers, state, RABBITMQ_TRANSPORT_TYPE)
+            NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(headers, library) # to handle the new w3c headers
+            txn.distributed_tracer.consume_message_headers(headers, state, library) # to do the expected old things
             CrossAppTracing.reject_messaging_cat_headers(headers).each do |k, v|
               txn.add_agent_attribute(:"message.headers.#{k}", v, AttributeFilter::DST_NONE) unless v.nil?
             end
@@ -179,6 +182,7 @@ module NewRelic
       #
       # @return [NewRelic::Agent::Transaction::MessageBrokerSegment]
       #
+      # @!scope class
       # @api public
       #
       def start_amqp_publish_segment(library:,
@@ -239,6 +243,7 @@ module NewRelic
       #
       # @return [NewRelic::Agent::Transaction::MessageBrokerSegment]
       #
+      # @!scope class
       # @api public
       #
       def start_amqp_consume_segment(library:,
@@ -300,6 +305,7 @@ module NewRelic
       # @return return value of given block, which will be the same as the
       #   return value of an un-instrumented subscribed callback
       #
+      # @!scope class
       # @api public
       #
       def wrap_amqp_consume_transaction(library: nil,
@@ -327,12 +333,17 @@ module NewRelic
         NewRelic::Agent.config[:'message_tracer.segment_parameters.enabled']
       end
 
-      def transaction_name(library, destination_type, destination_name)
+      def transaction_name(library, destination_type, destination_name, action = nil)
         transaction_name = Transaction::MESSAGE_PREFIX + library
         transaction_name << NewRelic::SLASH
         transaction_name << Transaction::MessageBrokerSegment::TYPES[destination_type]
         transaction_name << NewRelic::SLASH
 
+        if action == :consume
+          transaction_name << 'Consume'
+          transaction_name << NewRelic::SLASH
+        end
+
         case destination_type
         when :queue
           transaction_name << Transaction::MessageBrokerSegment::NAMED

data/lib/new_relic/agent/method_tracer.rb

@@ -65,6 +65,7 @@ module NewRelic
       # categories, but generally this *should never ever be done*.  Most of the time you can aggregate
       # on the server.
       #
+      # @!scope class
       # @api public
       #
       def trace_execution_scoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
@@ -81,6 +82,7 @@ module NewRelic
       #
       # * <tt>metric_names</tt> is a single name or an array of names of metrics
       #
+      # @!scope class
       # @api public
       #
       def trace_execution_unscoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
@@ -241,6 +243,7 @@ module NewRelic
         #   # Instrument foo in transaction traces only
         #   add_method_tracer :foo, 'Custom/foo', :metric => false
         #
+        # @!scope class
         # @api public
         #
         def add_method_tracer(method_name, metric_name = nil, options = {})

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

@@ -32,7 +32,7 @@ module NewRelic
 
       def deserialize_header(encoded_header, key)
         decoded_header = obfuscator.deobfuscate(encoded_header)
-        ::JSON.load(decoded_header)
+        ::JSON.parse(decoded_header)
       rescue => err
         # If we have a failure of any type here, just return nil and carry on
         NewRelic::Agent.logger.debug("Failure deserializing encoded header '#{key}' in #{self.class}, #{err.class}, #{err.message}")

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

@@ -35,7 +35,7 @@ module NewRelic
       end
 
       def load_json(header, key)
-        ::JSON.load(header)
+        ::JSON.parse(header)
       rescue => err
         NewRelic::Agent.logger.debug("Failure loading json header '#{key}' in #{self.class}, #{err.class}, #{err.message}")
         nil

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

@@ -19,7 +19,7 @@ module NewRelic
         def warn_for_yajl
           if defined?(::Yajl)
             require 'yajl/version'
-            if Gem::Version.new(::Yajl::VERSION) < OK_YAJL_VERSION
+            if NewRelic::Helper.version_satisfied?(::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.")
             end
           end
@@ -42,7 +42,7 @@ module NewRelic
             return nil
           end
 
-          return_value(::JSON.load(data))
+          return_value(::JSON.parse(data))
         rescue => e
           ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} encountered loading collector response: #{data}")
           raise

data/lib/new_relic/agent/new_relic_service.rb

@@ -455,6 +455,8 @@ module NewRelic
       end
 
       def handle_error_response(response, endpoint)
+        NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::HTTP_ERROR, [response.code, endpoint])
+
         case response
         when Net::HTTPRequestTimeOut,
              Net::HTTPTooManyRequests,
@@ -637,9 +639,13 @@ module NewRelic
       def send_request(opts)
         request = prep_request(opts)
         response = relay_request(request, opts)
-        return response if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
 
-        handle_error_response(response, opts[:endpoint])
+        if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+          NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::HEALTHY)
+          response
+        else
+          handle_error_response(response, opts[:endpoint])
+        end
       end
 
       def log_response(response)