newrelic_rpm 8.5.0 → 8.6.0

data/lib/new_relic/agent/log_event_aggregator.rb

@@ -0,0 +1,234 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require 'new_relic/agent/event_aggregator'
+require 'new_relic/agent/log_priority'
+
+module NewRelic
+  module Agent
+    class LogEventAggregator < EventAggregator
+      # Per-message keys
+      LEVEL_KEY = "log.level".freeze
+      MESSAGE_KEY = "message".freeze
+      TIMESTAMP_KEY = "timestamp".freeze
+      PRIORITY_KEY = "priority".freeze
+
+      # Metric keys
+      LINES = "Logging/lines".freeze
+      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
+      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
+      MAX_BYTES = 32768 # 32 * 1024 bytes (32 kibibytes)
+
+      named :LogEventAggregator
+      buffer_class PrioritySampledBuffer
+
+      capacity_key :'application_logging.forwarding.max_samples_stored'
+      enabled_key :'application_logging.enabled'
+
+      # Config keys
+      OVERALL_ENABLED_KEY = :'application_logging.enabled'
+      METRICS_ENABLED_KEY = :'application_logging.metrics.enabled'
+      FORWARDING_ENABLED_KEY = :'application_logging.forwarding.enabled'
+      DECORATING_ENABLED_KEY = :'application_logging.local_decorating.enabled'
+
+      def initialize(events)
+        super(events)
+        @counter_lock = Mutex.new
+        @seen = 0
+        @seen_by_severity = Hash.new(0)
+        @high_security = NewRelic::Agent.config[:high_security]
+        @instrumentation_logger_enabled = NewRelic::Agent::Instrumentation::Logger.enabled?
+        register_for_done_configuring(events)
+      end
+
+      def capacity
+        @buffer.capacity
+      end
+
+      def record(formatted_message, severity)
+        return unless enabled?
+
+        severity = "UNKNOWN" if severity.nil? || severity.empty?
+
+        if NewRelic::Agent.config[METRICS_ENABLED_KEY]
+          @counter_lock.synchronize do
+            @seen += 1
+            @seen_by_severity[severity] += 1
+          end
+        end
+
+        return if formatted_message.nil? || formatted_message.empty?
+        return unless NewRelic::Agent.config[:'application_logging.forwarding.enabled']
+        return if @high_security
+
+        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
+          end
+        end
+      rescue
+        nil
+      end
+
+      def record_batch txn, logs
+        # Ensure we have the same shared priority
+        priority = LogPriority.priority_for(txn)
+        logs.each do |log|
+          log.first[PRIORITY_KEY] = priority
+        end
+
+        @lock.synchronize do
+          logs.each do |log|
+            @buffer.append(event: log)
+          end
+        end
+      end
+
+      def create_event priority, formatted_message, severity
+        formatted_message = truncate_message(formatted_message)
+
+        event = LinkingMetadata.append_trace_linking_metadata({
+          LEVEL_KEY => severity,
+          MESSAGE_KEY => formatted_message,
+          TIMESTAMP_KEY => Process.clock_gettime(Process::CLOCK_REALTIME) * 1000
+        })
+
+        [
+          {
+            PrioritySampledBuffer::PRIORITY_KEY => priority
+          },
+          event
+        ]
+      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.
+      #
+      # Payload shape matches the publicly documented MELT format.
+      # https://docs.newrelic.com/docs/logs/log-api/introduction-log-api
+      #
+      # We have to keep the aggregated payloads in a separate shape, though, to
+      # work with the priority sampling buffers
+      def self.payload_to_melt_format(data)
+        common_attributes = LinkingMetadata.append_service_linking_metadata({})
+
+        # To save on unnecessary data transmission, trim the entity.type
+        # sent by classic logs-in-context
+        common_attributes.delete(ENTITY_TYPE_KEY)
+
+        _, items = data
+        payload = [{
+          common: {attributes: common_attributes},
+          logs: items.map(&:last)
+        }]
+
+        return [payload, items.size]
+      end
+
+      def harvest!
+        record_customer_metrics()
+        super
+      end
+
+      def reset!
+        @counter_lock.synchronize do
+          @seen = 0
+          @seen_by_severity.clear
+        end
+        super
+      end
+
+      def enabled?
+        @enabled && @instrumentation_logger_enabled
+      end
+
+      private
+
+      # We record once-per-connect metrics for enabled/disabled state at the
+      # point we consider the configuration stable (i.e. once we've gotten SSC)
+      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(METRICS_SUPPORTABILITY_FORMAT, METRICS_ENABLED_KEY)
+          record_configuration_metric(FORWARDING_SUPPORTABILITY_FORMAT, FORWARDING_ENABLED_KEY)
+          record_configuration_metric(DECORATING_SUPPORTABILITY_FORMAT, DECORATING_ENABLED_KEY)
+        end
+      end
+
+      def record_configuration_metric(format, key)
+        state = NewRelic::Agent.config[key]
+        label = if !enabled?
+          "disabled"
+        else
+          state ? "enabled" : "disabled"
+        end
+        NewRelic::Agent.increment_metric(format % label)
+      end
+
+      def after_harvest metadata
+        dropped_count = metadata[:seen] - metadata[:captured]
+        note_dropped_events(metadata[:seen], dropped_count)
+        record_supportability_metrics(metadata[:seen], metadata[:captured], dropped_count)
+      end
+
+      # To avoid paying the cost of metric recording on every line, we hold
+      # these until harvest before recording them
+      def record_customer_metrics
+        return unless enabled?
+        return unless NewRelic::Agent.config[:'application_logging.metrics.enabled']
+
+        @counter_lock.synchronize do
+          return unless @seen > 0
+
+          NewRelic::Agent.increment_metric(LINES, @seen)
+          @seen_by_severity.each do |(severity, count)|
+            NewRelic::Agent.increment_metric(line_metric_name_by_severity(severity), count)
+          end
+
+          @seen = 0
+          @seen_by_severity.clear
+        end
+      end
+
+      def line_metric_name_by_severity(severity)
+        @line_metrics ||= {}
+        @line_metrics[severity] ||= "Logging/lines/#{severity}".freeze
+      end
+
+      def note_dropped_events total_count, dropped_count
+        if dropped_count > 0
+          NewRelic::Agent.logger.warn("Dropped #{dropped_count} log events out of #{total_count}.")
+        end
+      end
+
+      def record_supportability_metrics total_count, captured_count, dropped_count
+        return unless total_count > 0
+
+        NewRelic::Agent.increment_metric(DROPPED_METRIC, dropped_count)
+        NewRelic::Agent.increment_metric(SEEN_METRIC, total_count)
+        NewRelic::Agent.increment_metric(SENT_METRIC, captured_count)
+      end
+
+      def truncate_message(message)
+        return message if message.bytesize <= MAX_BYTES
+        message.byteslice(0...MAX_BYTES)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/log_priority.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require 'new_relic/agent/event_aggregator'
+
+# Stateless calculation of priority for a given log event
+module NewRelic
+  module Agent
+    module LogPriority
+      extend self
+
+      def priority_for(txn)
+        return txn.priority if txn
+
+        rand.round(NewRelic::PRIORITY_PRECISION)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service.rb

@@ -177,18 +177,25 @@ module NewRelic
           :item_count => items.size)
       end
 
+      def log_event_data(data)
+        payload, size = LogEventAggregator.payload_to_melt_format(data)
+        invoke_remote(:log_event_data, payload, :item_count => size)
+      end
+
       def error_event_data(data)
         metadata, items = data
-        invoke_remote(:error_event_data, [@agent_id, *data], :item_count => items.size)
+        response = invoke_remote(:error_event_data, [@agent_id, *data], :item_count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Sent", :count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/TransactionError/Seen", :count => metadata[:events_seen])
+        response
       end
 
       def span_event_data(data)
         metadata, items = data
-        invoke_remote(:span_event_data, [@agent_id, *data], :item_count => items.size)
+        response = invoke_remote(:span_event_data, [@agent_id, *data], :item_count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/SpanEvents/Sent", :count => items.size)
         NewRelic::Agent.record_metric("Supportability/Events/SpanEvents/Seen", :count => metadata[:events_seen])
+        response
       end
 
       # We do not compress if content is smaller than 64kb.  There are
@@ -454,7 +461,7 @@ module NewRelic
       def handle_serialization_error(method, e)
         NewRelic::Agent.increment_metric("Supportability/serialization_failure")
         NewRelic::Agent.increment_metric("Supportability/serialization_failure/#{method}")
-        msg = "Failed to serialize #{method} data using #{@marshaller.class.to_s}: #{e.inspect}"
+        msg = "Failed to serialize #{method} data using #{@marshaller.class}: #{e.inspect}"
         error = SerializationError.new(msg)
         error.set_backtrace(e.backtrace)
         raise error
@@ -464,11 +471,11 @@ module NewRelic
         serialize_time = serialize_finish_ts && (serialize_finish_ts - start_ts)
         request_duration = response_check_ts && (response_check_ts - request_send_ts)
         if request_duration
-          NewRelic::Agent.record_metric("Supportability/Agent/Collector/#{method.to_s}/Duration", request_duration)
+          NewRelic::Agent.record_metric("Supportability/Agent/Collector/#{method}/Duration", request_duration)
         end
         if serialize_time
           NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
-          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
+          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method}", serialize_time)
         end
       end
 
@@ -482,8 +489,8 @@ module NewRelic
       # of items as arguments.
       def record_size_supportability_metrics(method, size_bytes, item_count)
         metrics = [
-          "Supportability/invoke_remote_size",
-          "Supportability/invoke_remote_size/#{method.to_s}"
+          "Supportability/Ruby/Collector/Output/Bytes",
+          "Supportability/Ruby/Collector/#{method}/Output/Bytes"
         ]
         # we may not have an item count, in which case, just record 0 for the exclusive time
         item_count ||= 0

data/lib/new_relic/agent/pipe_service.rb

@@ -61,6 +61,10 @@ module NewRelic
         write_to_pipe(:sql_trace_data, sql) if sql
       end
 
+      def log_event_data(logs)
+        write_to_pipe(:log_event_data, logs) if logs
+      end
+
       def shutdown
         @pipe.close if @pipe
       end

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'new_relic/agent/sampler'
+require 'new_relic/helper'
 
 module NewRelic
   module Agent
@@ -46,7 +47,11 @@ module NewRelic
 
         def self.platform
           if RUBY_PLATFORM =~ /java/
-            %x(uname -s).downcase
+            begin
+              NewRelic::Helper.run_command('uname -s').downcase
+            rescue NewRelic::CommandRunFailedError, NewRelic::CommandExecutableNotFoundError
+              'unknown'
+            end
           else
             RUBY_PLATFORM.downcase
           end

data/lib/new_relic/agent/transaction.rb

@@ -77,6 +77,7 @@ module NewRelic
 
       attr_reader :guid,
         :metrics,
+        :logs,
         :gc_start_snapshot,
         :category,
         :attributes,
@@ -236,6 +237,7 @@ module NewRelic
 
         @exceptions = {}
         @metrics = TransactionMetrics.new
+        @logs = PrioritySampledBuffer.new(NewRelic::Agent.instance.log_event_aggregator.capacity)
         @guid = NewRelic::Agent::GuidGenerator.generate_guid
 
         @ignore_this_transaction = false
@@ -533,6 +535,7 @@ module NewRelic
 
         record_exceptions
         record_transaction_event
+        record_log_events
         merge_metrics
         send_transaction_finished_event
       end
@@ -732,6 +735,10 @@ module NewRelic
         agent.transaction_event_recorder.record payload
       end
 
+      def record_log_events
+        agent.log_event_aggregator.record_batch self, @logs.to_a
+      end
+
       def queue_time
         @apdex_start ? @start_time - @apdex_start : 0
       end
@@ -826,6 +833,10 @@ module NewRelic
         attributes.merge_custom_attributes(p)
       end
 
+      def add_log_event(event)
+        logs.append(event: event)
+      end
+
       def recording_web_transaction?
         web_category?(@category)
       end

data/lib/new_relic/agent.rb

@@ -59,6 +59,8 @@ module NewRelic
     require 'new_relic/agent/logging'
     require 'new_relic/agent/distributed_tracing'
     require 'new_relic/agent/attribute_processing'
+    require 'new_relic/agent/linking_metadata'
+    require 'new_relic/agent/local_log_decorator'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -726,20 +728,8 @@ module NewRelic
     # @api public
     def linking_metadata
       metadata = Hash.new
-      metadata[ENTITY_NAME_KEY] = config[:app_name][0]
-      metadata[ENTITY_TYPE_KEY] = ENTITY_TYPE
-      metadata[HOSTNAME_KEY] = Hostname.get
-
-      if entity_guid = config[:entity_guid]
-        metadata[ENTITY_GUID_KEY] = entity_guid
-      end
-
-      if trace_id = Tracer.current_trace_id
-        metadata[TRACE_ID_KEY] = trace_id
-      end
-      if span_id = Tracer.current_span_id
-        metadata[SPAN_ID_KEY] = span_id
-      end
+      LinkingMetadata.append_service_linking_metadata(metadata)
+      LinkingMetadata.append_trace_linking_metadata(metadata)
       metadata
     end
 

data/lib/new_relic/helper.rb

@@ -3,8 +3,12 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'new_relic/language_support'
+require 'open3'
 
 module NewRelic
+  class CommandExecutableNotFoundError < StandardError; end
+  class CommandRunFailedError < StandardError; end
+
   # A singleton for shared generic helper methods
   module Helper
     extend self
@@ -40,5 +44,41 @@ module NewRelic
     def time_to_millis(time)
       (time.to_f * 1000).round
     end
+
+    def run_command(command)
+      executable = command.split(' ').first
+      unless executable_in_path?(executable)
+        raise NewRelic::CommandExecutableNotFoundError.new("Executable not found: '#{executable}'")
+      end
+
+      exception = nil
+      begin
+        output, status = Open3.capture2e(command)
+      rescue => exception
+      end
+
+      if exception || !status.success?
+        message = exception ? "#{exception.class} - #{exception.message}" : output
+        raise NewRelic::CommandRunFailedError.new("Failed to run command '#{command}': #{message}")
+      end
+
+      output.chomp
+    end
+
+    # TODO: Open3 defers the actual excecution of a binary to Process.spawn,
+    #       which will raise an Errno::ENOENT exception for a file that
+    #       cannot be found. We might want to take the time to evaluate
+    #       relying on that Process.spawn behavior instead of checking for
+    #       existence ourselves. We'd need to see what it does, how efficient
+    #       it is, if it differs in functionality between Ruby versions and
+    #       operating systems, etc.
+    def executable_in_path?(executable)
+      return false unless ENV['PATH']
+
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |bin_path|
+        executable_path = File.join(bin_path, executable)
+        File.exist?(executable_path) && File.file?(executable_path) && File.executable?(executable_path)
+      end
+    end
   end
 end

data/lib/new_relic/version.rb

@@ -6,7 +6,7 @@
 module NewRelic
   module VERSION # :nodoc:
     MAJOR = 8
-    MINOR = 5
+    MINOR = 6
     TINY = 0
 
     STRING = "#{MAJOR}.#{MINOR}.#{TINY}"

data/lib/tasks/config.rake

@@ -11,8 +11,8 @@ namespace :newrelic do
       DISABLING => 'Use these settings to toggle instrumentation types during agent startup.',
       ATTRIBUTES => '[Attributes](/docs/features/agent-attributes) are key-value pairs containing information that determines the properties of an event or transaction. These key-value pairs can be viewed within transaction traces in APM, traced errors in APM, transaction events in dashboards, and page views in dashboards. You can customize exactly which attributes will be sent to each of these destinations',
       "transaction_tracer" => 'The [transaction traces](/docs/apm/traces/transaction-traces/transaction-traces) feature collects detailed information from a selection of transactions, including a summary of the calling sequence, a breakdown of time spent, and a list of SQL queries and their query plans (on mysql and postgresql). Available features depend on your New Relic subscription level.',
-      "error_collector" => 'The agent collects and reports all uncaught exceptions by default. These configuration options allow you to customize the error collection.',
-      "browser_monitoring" => 'The Browser monitoring [page load timing](/docs/browser/new-relic-browser/page-load-timing/page-load-timing-process) feature (sometimes referred to as real user monitoring or RUM) gives you insight into the performance real users are experiencing with your website. This is accomplished by measuring the time it takes for your users\' browsers to download and render your web pages by injecting a small amount of JavaScript code into the header and footer of each page.',
+      "error_collector" => 'The agent collects and reports all uncaught exceptions by default. These configuration options allow you to customize the error collection.\nFor information on ignored and expected errors, [see this page on Error Analytics in APM](/docs/agents/manage-apm-agents/agent-data/manage-errors-apm-collect-ignore-or-mark-expected/). To set expected errors via the `NewRelic::Agent.notice_error` Ruby method, [consult the Ruby Agent API](/docs/agents/ruby-agent/api-guides/sending-handled-errors-new-relic/).',
+      "browser_monitoring" => "The browser monitoring [page load timing](/docs/browser/new-relic-browser/page-load-timing/page-load-timing-process) feature (sometimes referred to as real user monitoring or RUM) gives you insight into the performance real users are experiencing with your website. This is accomplished by measuring the time it takes for your users' browsers to download and render your web pages by injecting a small amount of JavaScript code into the header and footer of each page.",
       "analytics_events" => '[New Relic dashboards](/docs/query-your-data/explore-query-data/dashboards/introduction-new-relic-one-dashboards) is a resource to gather and visualize data about your software and what it says about your business. With it you can quickly and easily create real-time dashboards to get immediate answers about end-user experiences, clickstreams, mobile activities, and server transactions.'
     }
 
@@ -24,7 +24,7 @@ namespace :newrelic do
       config_hash = build_config_hash
       sections = flatten_config_hash(config_hash)
 
-      puts build_erb(format).result(binding)
+      puts build_erb(format).result(binding).split("\n").map(&:rstrip).join("\n").gsub('.  ', '. ')
       sections # silences unused warning to return this
     end
 

data/newrelic.yml

@@ -26,6 +26,22 @@ common: &default_settings
 # All of the following configuration options are optional. Review them, and
 # uncomment or edit them if they appear relevant to your application needs.
 
+# If `true`, all logging-related features for the agent can be enabled or disabled
+# independently. If `false`, all logging-related features are disabled.
+# application_logging.enabled: true
+
+# If `true`, the agent captures log records emitted by this application.
+# application_logging.forwarding.enabled: false
+
+# Defines the maximum number of log records to buffer in memory at a time.
+# application_logging.forwarding.max_samples_stored: 10000
+
+# If `true`, the agent captures metrics related to logging for this application.
+# application_logging.metrics.enabled: true
+
+# If `true`, the agent decorates logs with metadata to link to entities, hosts, traces, and spans.
+# application_logging.local_decorating.enabled: false
+
 # If true, enables transaction event sampling.
 # transaction_events.enabled: true
 
@@ -82,10 +98,6 @@ common: &default_settings
 # end.
 # browser_monitoring.attributes.include: []
 
-# If true, enables auto-injection of the JavaScript header for page load timing
-# (sometimes referred to as real user monitoring or RUM).
-# browser_monitoring.auto_instrument: false
-
 # This is true by default, this enables auto-injection of the JavaScript header
 # for page load timing (sometimes referred to as real user monitoring or RUM).
 # browser_monitoring.auto_instrument: true
@@ -317,6 +329,10 @@ common: &default_settings
 # May be one of [auto|prepend|chain|disabled].
 # instrumentation.logger: auto
 
+# Controls auto-instrumentation of ActiveSupport::Logger at start up.
+# May be one of [auto|prepend|chain|disabled].
+# instrumentation.active_support.logger: auto
+
 # Controls auto-instrumentation of memcache-client gem for Memcache at start up.
 # May be one of [auto|prepend|chain|disabled].
 # instrumentation.memcache_client: auto

data/newrelic_rpm.gemspec

@@ -52,6 +52,7 @@ https://github.com/newrelic/newrelic-ruby-agent/
   s.add_development_dependency 'rb-inotify', '0.9.10' # locked to support < Ruby 2.3 (and listen 3.0.8)
   s.add_development_dependency 'listen', '3.0.8' # locked to support < Ruby 2.3
   s.add_development_dependency 'minitest', '4.7.5'
+  s.add_development_dependency 'minitest-stub-const', '0.6'
   s.add_development_dependency 'mocha', '~> 1.9.0'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'pry-nav', '~> 0.3.0'

data/test/agent_helper.rb

@@ -218,16 +218,30 @@ end
 def assert_stats_has_values stats, expected_spec, expected_attrs
   expected_attrs.each do |attr, expected_value|
     actual_value = stats.send(attr)
+
+    msg = "Expected #{attr} for #{expected_spec} to be #{'~' unless attr == :call_count}#{expected_value}, " \
+          "got #{actual_value}.\nActual stats:\n#{dump_stats(stats)}"
+
     if attr == :call_count
-      assert_equal(expected_value, actual_value,
-        "Expected #{attr} for #{expected_spec} to be #{expected_value}, got #{actual_value}.\nActual stats:\n#{dump_stats(stats)}")
+      assert_stats_has_values_with_call_count(expected_value, actual_value, msg)
     else
-      assert_in_delta(expected_value, actual_value, 0.0001,
-        "Expected #{attr} for #{expected_spec} to be ~#{expected_value}, got #{actual_value}.\nActual stats:\n#{dump_stats(stats)}")
+      assert_in_delta(expected_value, actual_value, 0.0001, msg)
     end
   end
 end
 
+def assert_stats_has_values_with_call_count(expected_value, actual_value, msg)
+  # >, <, >=, <= comparisons
+  if expected_value.to_s =~ /([<>]=?)\s*(\d+)/
+    operator = Regexp.last_match(1).to_sym
+    count = Regexp.last_match(2).to_i
+    assert_operator(actual_value, operator, count, msg)
+  # == comparison
+  else
+    assert_equal(expected_value, actual_value, msg)
+  end
+end
+
 def assert_metrics_recorded expected
   expected = _normalize_metric_expectations(expected)
   expected.each do |specish, expected_attrs|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 8.5.0
+  version: 8.6.0
 platform: ruby
 authors:
 - Tanna McClure
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -68,6 +68,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 4.7.5
+- !ruby/object:Gem::Dependency
+  name: minitest-stub-const
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -242,7 +256,6 @@ files:
 - Guardfile
 - LICENSE
 - README.md
-- ROADMAP.md
 - Rakefile
 - THIRD_PARTY_NOTICES.md
 - bin/mongrel_rpm
@@ -341,6 +354,10 @@ files:
 - lib/new_relic/agent/instrumentation/active_record_subscriber.rb
 - lib/new_relic/agent/instrumentation/active_storage.rb
 - lib/new_relic/agent/instrumentation/active_storage_subscriber.rb
+- lib/new_relic/agent/instrumentation/active_support_logger.rb
+- lib/new_relic/agent/instrumentation/active_support_logger/chain.rb
+- lib/new_relic/agent/instrumentation/active_support_logger/instrumentation.rb
+- lib/new_relic/agent/instrumentation/active_support_logger/prepend.rb
 - lib/new_relic/agent/instrumentation/acts_as_solr.rb
 - lib/new_relic/agent/instrumentation/authlogic.rb
 - lib/new_relic/agent/instrumentation/bunny.rb
@@ -441,7 +458,11 @@ files:
 - lib/new_relic/agent/instrumentation/typhoeus/prepend.rb
 - lib/new_relic/agent/internal_agent_error.rb
 - lib/new_relic/agent/javascript_instrumentor.rb
+- lib/new_relic/agent/linking_metadata.rb
+- lib/new_relic/agent/local_log_decorator.rb
+- lib/new_relic/agent/log_event_aggregator.rb
 - lib/new_relic/agent/log_once.rb
+- lib/new_relic/agent/log_priority.rb
 - lib/new_relic/agent/logging.rb
 - lib/new_relic/agent/memory_logger.rb
 - lib/new_relic/agent/messaging.rb