newrelic_rpm 9.16.0 → 9.17.0

data/lib/new_relic/agent/health_check.rb

@@ -0,0 +1,136 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    class HealthCheck
+      def initialize
+        @start_time = nano_time
+        @continue = true
+        @status = HEALTHY
+        # the following assignments may set @continue = false if they are invalid
+        set_enabled
+        set_delivery_location
+        set_frequency
+      end
+
+      HEALTHY = {healthy: true, last_error: 'NR-APM-000', message: 'Healthy'}.freeze
+      INVALID_LICENSE_KEY = {healthy: false, last_error: 'NR-APM-001', message: 'Invalid license key (HTTP status code 401)'}.freeze
+      MISSING_LICENSE_KEY = {healthy: false, last_error: 'NR-APM-002', message: 'License key missing in configuration'}.freeze
+      FORCED_DISCONNECT = {healthy: false, last_error: 'NR-APM-003', message: 'Forced disconnect received from New Relic (HTTP status code 410)'}.freeze
+      HTTP_ERROR = {healthy: false, last_error: 'NR-APM-004', message: 'HTTP error response code [%s] recevied from New Relic while sending data type [%s]'}.freeze
+      MISSING_APP_NAME = {healthy: false, last_error: 'NR-APM-005', message: 'Missing application name in agent configuration'}.freeze
+      APP_NAME_EXCEEDED = {healthy: false, last_error: 'NR-APM-006', message: 'The maximum number of configured app names (3) exceeded'}.freeze
+      PROXY_CONFIG_ERROR = {healthy: false, last_error: 'NR-APM-007', message: 'HTTP Proxy configuration error; response code [%s]'}.freeze
+      AGENT_DISABLED = {healthy: false, last_error: 'NR-APM-008', message: 'Agent is disabled via configuration'}.freeze
+      FAILED_TO_CONNECT = {healthy: false, last_error: 'NR-APM-009', message: 'Failed to connect to New Relic data collector'}.freeze
+      FAILED_TO_PARSE_CONFIG = {healthy: false, last_error: 'NR-APM-010', message: 'Agent config file is not able to be parsed'}.freeze
+      SHUTDOWN = {healthy: true, last_error: 'NR-APM-099', message: 'Agent has shutdown'}.freeze
+
+      def create_and_run_health_check_loop
+        return unless health_checks_enabled? && @continue
+
+        NewRelic::Agent.logger.debug('Agent Control health check conditions met. Starting health checks.')
+        NewRelic::Agent.record_metric('Supportability/AgentControl/Health/enabled', 1)
+
+        Thread.new do
+          while @continue
+            begin
+              sleep @frequency
+              write_file
+              @continue = false if @status == SHUTDOWN
+            rescue StandardError => e
+              NewRelic::Agent.logger.error("Aborting Agent Control health check. Error raised: #{e}")
+              @continue = false
+            end
+          end
+        end
+      end
+
+      def update_status(status, options = [])
+        return unless @continue
+
+        @status = status.dup
+        update_message(options) unless options.empty?
+      end
+
+      def healthy?
+        @status == HEALTHY
+      end
+
+      private
+
+      def set_enabled
+        @enabled = if ENV['NEW_RELIC_AGENT_CONTROL_ENABLED'] == 'true'
+          true
+        else
+          NewRelic::Agent.logger.debug('NEW_RELIC_AGENT_CONTROL_ENABLED not true, disabling health checks')
+          @continue = false
+          false
+        end
+      end
+
+      def set_delivery_location
+        @delivery_location = if ENV['NEW_RELIC_AGENT_CONTROL_HEALTH_DELIVERY_LOCATION']
+          # The spec states file paths for the delivery location will begin with file://
+          # This does not create a valid path in Ruby, so remove the prefix when present
+          ENV['NEW_RELIC_AGENT_CONTROL_HEALTH_DELIVERY_LOCATION']&.gsub('file://', '')
+        else
+          # The spec default is 'file:///newrelic/apm/health', but since we're just going to remove it anyway...
+          '/newrelic/apm/health'
+        end
+      end
+
+      def set_frequency
+        @frequency = ENV['NEW_RELIC_AGENT_CONTROL_HEALTH_FREQUENCY'] ? ENV['NEW_RELIC_AGENT_CONTROL_HEALTH_FREQUENCY'].to_i : 5
+
+        if @frequency <= 0
+          NewRelic::Agent.logger.debug('NEW_RELIC_AGENT_CONTROL_HEALTH_FREQUENCY zero or less, disabling health checks')
+          @continue = false
+        end
+      end
+
+      def contents
+        <<~CONTENTS
+          healthy: #{@status[:healthy]}
+          status: #{@status[:message]}#{last_error}
+          start_time_unix_nano: #{@start_time}
+          status_time_unix_nano: #{nano_time}
+        CONTENTS
+      end
+
+      def last_error
+        @status[:healthy] ? '' : "\nlast_error: #{@status[:last_error]}"
+      end
+
+      def nano_time
+        Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+      end
+
+      def file_name
+        "health-#{NewRelic::Agent::GuidGenerator.generate_guid(32)}.yml"
+      end
+
+      def write_file
+        @file ||= "#{@delivery_location}/#{file_name}"
+
+        File.write(@file, contents)
+      rescue StandardError => e
+        NewRelic::Agent.logger.error("Agent Control health check raised an error while writing a file: #{e}")
+        @continue = false
+      end
+
+      def health_checks_enabled?
+        @enabled && @delivery_location && @frequency > 0
+      end
+
+      def update_message(options)
+        @status[:message] = sprintf(@status[:message], *options)
+      rescue StandardError => e
+        NewRelic::Agent.logger.debug("Error raised while updating Agent Control health check message: #{e}." \
+          "options = #{options}, @status[:message] = #{@status[:message]}")
+      end
+    end
+  end
+end

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

@@ -170,6 +170,9 @@ module NewRelic
 
           'sqlite3' => 'SQLite',
 
+          # https://rubygems.org/gems/trilogy
+          'trilogy' => 'MySQL',
+
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
           'jdbcmysql' => 'MySQL',
 
@@ -222,7 +225,8 @@ module NewRelic
 
             'postgresql' => :postgres,
             'jdbcpostgresql' => :postgres,
-            'postgis' => :postgres
+            'postgis' => :postgres,
+            'redshift' => :postgres
           }.freeze
 
           DATASTORE_DEFAULT_PORTS = {

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

@@ -116,10 +116,14 @@ module NewRelic
           port_path_or_id = nil
           database = nil
 
-          if ActiveRecordHelper::InstanceIdentification.supported_adapter?(config)
-            host = ActiveRecordHelper::InstanceIdentification.host(config)
-            port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
-            database = config && config[:database]
+          begin
+            if ActiveRecordHelper::InstanceIdentification.supported_adapter?(config)
+              host = ActiveRecordHelper::InstanceIdentification.host(config)
+              port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
+              database = config && config[:database]
+            end
+          rescue
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord host, port, and database details for adapter: #{config && config[:adapter]}")
           end
 
           segment = Tracer.start_datastore_segment(product: product,

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

@@ -0,0 +1,21 @@
+# 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 Firehose::Chain
+    def self.instrument!
+      ::Aws::Firehose::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::Firehose
+
+        NewRelic::Agent::Instrumentation::Firehose::INSTRUMENTED_METHODS.each do |method_name|
+          alias_method("#{method_name}_without_new_relic".to_sym, method_name.to_sym)
+
+          define_method(method_name) do |*args|
+            instrument_method_with_new_relic(method_name, *args) { send("#{method_name}_without_new_relic".to_sym, *args) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/aws_sdk_firehose/instrumentation.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
+
+module NewRelic::Agent::Instrumentation
+  module Firehose
+    INSTRUMENTED_METHODS = %w[
+      create_delivery_stream
+      delete_delivery_stream
+      describe_delivery_stream
+      list_delivery_streams
+      list_tags_for_delivery_stream
+      put_record
+      put_record_batch
+      start_delivery_stream_encryption
+      stop_delivery_stream_encryption
+      tag_delivery_stream
+      untag_delivery_stream
+      update_destination
+    ].freeze
+
+    FIREHOSE = 'Firehose'
+    AWS_KINESIS_DELIVERY_STREAMS = 'aws_kinesis_delivery_streams'
+
+    def instrument_method_with_new_relic(method_name, *args)
+      return yield unless NewRelic::Agent::Tracer.tracing_enabled?
+
+      NewRelic::Agent.record_instrumentation_invocation(FIREHOSE)
+
+      params = args[0]
+      segment = NewRelic::Agent::Tracer.start_segment(name: get_segment_name(method_name, params))
+      arn = get_arn(params) if params
+      segment&.add_agent_attribute('cloud.resource_id', arn) if arn
+
+      begin
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        segment&.add_agent_attribute('cloud.platform', AWS_KINESIS_DELIVERY_STREAMS)
+        segment&.finish
+      end
+    end
+
+    def get_segment_name(method_name, params)
+      stream_name = params&.dig(:delivery_stream_name)
+      return "#{FIREHOSE}/#{method_name}/#{stream_name}" if stream_name
+
+      "#{FIREHOSE}/#{method_name}"
+    rescue => e
+      NewRelic::Agent.logger.warn("Failed to create segment name: #{e}")
+    end
+
+    def nr_account_id
+      return @nr_account_id if defined?(@nr_account_id)
+
+      @nr_account_id = NewRelic::Agent::Aws.get_account_id(config)
+    end
+
+    def get_arn(params)
+      stream_arn = params&.dig(:delivery_stream_arn)
+      return stream_arn if stream_arn
+
+      stream_name = params&.dig(:delivery_stream_name)
+      NewRelic::Agent::Aws.create_arn(FIREHOSE.downcase, "deliverystream/#{stream_name}", config&.region, nr_account_id) if stream_name
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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 Firehose::Prepend
+    include NewRelic::Agent::Instrumentation::Firehose
+
+    INSTRUMENTED_METHODS.each do |method_name|
+      define_method(method_name) do |*args|
+        instrument_method_with_new_relic(method_name, *args) { super(*args) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# 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 'aws_sdk_firehose/instrumentation'
+require_relative 'aws_sdk_firehose/chain'
+require_relative 'aws_sdk_firehose/prepend'
+
+DependencyDetection.defer do
+  named :aws_sdk_firehose
+
+  depends_on do
+    defined?(Aws::Firehose::Client)
+  end
+  executes do
+    if use_prepend?
+      prepend_instrument Aws::Firehose::Client, NewRelic::Agent::Instrumentation::Firehose::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Firehose::Chain
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# 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 Kinesis::Chain
+    def self.instrument!
+      ::Aws::Kinesis::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::Kinesis
+
+        NewRelic::Agent::Instrumentation::Kinesis::INSTRUMENTED_METHODS.each do |method_name|
+          alias_method("#{method_name}_without_new_relic".to_sym, method_name.to_sym)
+
+          define_method(method_name) do |*args|
+            instrument_method_with_new_relic(method_name, *args) { send("#{method_name}_without_new_relic".to_sym, *args) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# 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 Kinesis
+    INSTRUMENTED_METHODS = %w[
+      add_tags_to_stream
+      create_stream
+      decrease_stream_retention_period
+      delete_stream
+      describe_limits
+      describe_stream
+      disable_enhanced_monitoring
+      enable_enhanced_monitoring
+      get_records
+      get_shard_iterator
+      increase_stream_retention_period
+      list_streams
+      list_tags_for_stream
+      merge_shards
+      put_record
+      put_records
+      remove_tags_from_stream
+      split_shard
+      update_shard_count
+    ].freeze
+
+    KINESIS = 'Kinesis'
+    AWS_KINESIS_DATA_STREAMS = 'aws_kinesis_data_streams'
+    MESSAGE_BROKER_SEGMENT_METHODS = %w[put_record put_records get_records].freeze
+
+    def instrument_method_with_new_relic(method_name, *args)
+      return yield unless NewRelic::Agent::Tracer.tracing_enabled?
+
+      NewRelic::Agent.record_instrumentation_invocation(KINESIS)
+      params = args[0]
+      arn = get_arn(params) if params
+
+      if MESSAGE_BROKER_SEGMENT_METHODS.include?(method_name)
+        stream_name = get_stream_name(params, arn)
+        segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+          action: method_name == 'get_records' ? :consume : :produce,
+          library: KINESIS,
+          destination_type: :stream,
+          destination_name: stream_name
+        )
+      else
+        segment = NewRelic::Agent::Tracer.start_segment(name: get_segment_name(method_name, params))
+      end
+
+      segment&.add_agent_attribute('cloud.resource_id', arn) if arn
+
+      begin
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        segment&.add_agent_attribute('cloud.platform', AWS_KINESIS_DATA_STREAMS)
+        segment&.finish
+      end
+    end
+
+    def get_segment_name(method_name, params)
+      stream_name = params&.dig(:stream_name)
+      return "#{KINESIS}/#{method_name}/#{stream_name}" if stream_name
+
+      "#{KINESIS}/#{method_name}"
+    rescue => e
+      NewRelic::Agent.logger.warn("Failed to create segment name: #{e}")
+    end
+
+    def get_stream_name(params, arn)
+      params&.dig(:stream_name) || arn.split('/').last || 'unknown'
+    rescue => e
+      NewRelic::Agent.logger.warn("Failed to get stream name: #{e}")
+    end
+
+    def nr_account_id
+      return @nr_account_id if defined?(@nr_account_id)
+
+      @nr_account_id = NewRelic::Agent::Aws.get_account_id(config)
+    end
+
+    def get_arn(params)
+      stream_arn = params&.dig(:stream_arn)
+      return stream_arn if stream_arn
+
+      stream_name = params&.dig(:stream_name)
+      NewRelic::Agent::Aws.create_arn(KINESIS.downcase, "stream/#{stream_name}", config&.region, nr_account_id) if stream_name
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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 Kinesis::Prepend
+    include NewRelic::Agent::Instrumentation::Kinesis
+
+    INSTRUMENTED_METHODS.each do |method_name|
+      define_method(method_name) do |*args|
+        instrument_method_with_new_relic(method_name, *args) { super(*args) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# 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 'aws_sdk_kinesis/instrumentation'
+require_relative 'aws_sdk_kinesis/chain'
+require_relative 'aws_sdk_kinesis/prepend'
+
+DependencyDetection.defer do
+  named :aws_sdk_kinesis
+
+  depends_on do
+    defined?(Aws::Kinesis::Client)
+  end
+  executes do
+    if use_prepend?
+      prepend_instrument Aws::Kinesis::Client, NewRelic::Agent::Instrumentation::Kinesis::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Kinesis::Chain
+    end
+  end
+end

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

@@ -63,10 +63,9 @@ module NewRelic::Agent::Instrumentation
     def generate_segment(action, options = {})
       function = function_name(options)
       region = aws_region
-      account_id = aws_account_id
       arn = aws_arn(function, region)
       segment = NewRelic::Agent::Tracer.start_segment(name: "Lambda/#{action}/#{function}")
-      segment.add_agent_attribute('cloud.account.id', account_id)
+      segment.add_agent_attribute('cloud.account.id', nr_account_id)
       segment.add_agent_attribute('cloud.platform', CLOUD_PLATFORM)
       segment.add_agent_attribute('cloud.region', region)
       segment.add_agent_attribute('cloud.resource_id', arn) if arn
@@ -77,18 +76,18 @@ module NewRelic::Agent::Instrumentation
       (options.fetch(:function_name, nil) if options.respond_to?(:fetch)) || NewRelic::UNKNOWN
     end
 
-    def aws_account_id
-      return unless self.respond_to?(:config)
-
-      config&.account_id || NewRelic::Agent.config[:'cloud.aws.account_id']
-    end
-
     def aws_region
       config&.region if self.respond_to?(:config)
     end
 
     def aws_arn(function, region)
-      NewRelic::Agent::Aws.create_arn(AWS_SERVICE, "function:#{function}", region)
+      NewRelic::Agent::Aws.create_arn(AWS_SERVICE, "function:#{function}", region, nr_account_id)
+    end
+
+    def nr_account_id
+      return @nr_account_id if defined?(@nr_account_id)
+
+      @nr_account_id = NewRelic::Agent::Aws.get_account_id(config)
     end
   end
 end

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

@@ -49,10 +49,16 @@ module NewRelic::Agent::Instrumentation
       @nr_captured_request = yield
     end
 
+    def nr_account_id
+      return @nr_account_id if defined?(@nr_account_id)
+
+      @nr_account_id = NewRelic::Agent::Aws.get_account_id(config)
+    end
+
     def get_arn(params)
       return unless params[:table_name]
 
-      NewRelic::Agent::Aws.create_arn(PRODUCT.downcase, "table/#{params[:table_name]}", config&.region)
+      NewRelic::Agent::Aws.create_arn(PRODUCT.downcase, "table/#{params[:table_name]}", config&.region, nr_account_id)
     end
   end
 end

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

@@ -56,10 +56,7 @@ module NewRelic::Agent::Instrumentation
 
       def name_transaction(route, class_name, version)
         txn_name = name_for_transaction(route, class_name, version)
-        segment_name = "Middleware/Grape/#{class_name}/call"
         NewRelic::Agent::Transaction.set_default_transaction_name(txn_name, :grape)
-        txn = NewRelic::Agent::Transaction.tl_current
-        txn.segments.last.name = segment_name
       end
 
       def name_for_transaction(route, class_name, version)

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

@@ -19,7 +19,13 @@ DependencyDetection.defer do
   end
 
   executes do
-    if NewRelic::Agent.config[:'resque.use_ruby_dns'] && NewRelic::Agent.config[:dispatcher] == :resque
+    if NewRelic::Agent.config[:'resque.use_ruby_dns'] &&
+        NewRelic::Agent.config[:dispatcher] == :resque &&
+        # resolv-replace is no longer part of the language in Ruby 3.4.
+        # we don't believe this lib is still necessary for Ruby 3.4 users.
+        # however, if we receive customer feedback to the contrary, we can find
+        # an alternate approach.
+        Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.4')
       NewRelic::Agent.logger.info('Requiring resolv-replace')
       require 'resolv'
       require 'resolv-replace'

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

@@ -6,7 +6,7 @@
 #       Delayed extensions are disabled by default in Sidekiq 5 and 6 and
 #       were removed entirely in Sidekiq 7.
 #
-#       see https://github.com/mperham/sidekiq/issues/5076 for the discussion
+#       see https://github.com/sidekiq/sidekiq/issues/5076 for the discussion
 #       of the removal, which includes mentions of alternatives
 if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
   class Sidekiq::Extensions::DelayedClass

data/lib/new_relic/agent/local_log_decorator.rb

@@ -9,7 +9,7 @@ module NewRelic
       extend self
 
       def decorate(message)
-        return message unless decorating_enabled?
+        return message if !decorating_enabled? || message.nil?
 
         metadata = NewRelic::Agent.linking_metadata
 
@@ -37,7 +37,17 @@ module NewRelic
       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 Gem::Version.new(URI::VERSION) >= Gem::Version.new('1.0')
+          URI::RFC2396_PARSER.escape(entity_name)
+        else
+          URI::DEFAULT_PARSER.escape(entity_name)
+        end
       end
     end
   end

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)

data/lib/new_relic/agent/threading/backtrace_node.rb

@@ -125,7 +125,16 @@ module NewRelic
 
         # Returns [filename, method, line number]
         def parse_backtrace_frame(frame)
-          frame =~ /([^:]*)(\:(\d+))?\:in `(.*)'/
+          # TODO: OLD RUBIES - Ruby 3.3
+          # The (?:`|') non-capturing group can be removed when the agent
+          # drops support for Ruby 3.3
+          # This group is used to capture the pre-Ruby 3.4.0 backtrace syntax.
+          # Example frame:
+          # Ruby 3.3.0 and below
+          # "irb.rb:69:in `catch'"
+          # Ruby 3.4.0+
+          # "irb.rb:69:in 'Kernel#catch'"
+          frame =~ /([^:]*)(\:(\d+))?\:in (?:`|')(.*)'/
           [$1, $4, $3] # sic
         end
       end

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

@@ -15,6 +15,7 @@ module NewRelic
         PRODUCE = 'Produce'.freeze
         QUEUE = 'Queue'.freeze
         PURGE = 'Purge'.freeze
+        STREAM = 'Stream'.freeze
         TEMP = 'Temp'.freeze
         TOPIC = 'Topic'.freeze
         UNKNOWN = 'Unknown'.freeze
@@ -22,6 +23,7 @@ module NewRelic
         DESTINATION_TYPES = [
           :exchange,
           :queue,
+          :stream,
           :topic,
           :temporary_queue,
           :temporary_topic,
@@ -37,6 +39,7 @@ module NewRelic
         TYPES = {
           exchange: EXCHANGE,
           temporary_queue: QUEUE,
+          stream: STREAM,
           queue: QUEUE,
           temporary_topic: TOPIC,
           topic: TOPIC,

data/lib/new_relic/agent.rb

@@ -132,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